Chrome Extension – Redmine Story Creation and README Push Workflow¶

Provide a Chrome Manifest V3 extension that converts generated README/story files into controlled Redmine issues, sub-tasks, or updates through a Redmine-aware workflow.

---

1. Executive Summary¶

This story covers the Chrome extension layer of Redmine README Sync.

The extension is the user-facing interface between locally generated project/story documentation and Redmine. It does not generate the README, call an AI service, scrape Claude/ChatGPT/Gemini pages, or contain Redmine credentials. Instead, it discovers README files supplied by the backend, lets the user review and configure the target Redmine project and issue operation, performs a dry-run preview, and then asks the backend to create or update the corresponding Redmine issue.

The implemented extension is a Chrome Manifest V3 application written in plain JavaScript with no Node/npm build step.

Core story-creation flow:

README / Story File
        |
        v
Chrome Extension
        |
        +--> Select README
        |
        +--> Suggest project / issue / fields
        |
        +--> User reviews or edits values
        |
        +--> Preview / dry run
        |
        v
Backend API
        |
        v
Redmine permission + validation
        |
        +--------------------+
        |                    |
        v                    v
   Create Issue          Update Issue
        |                    |
        +---------+----------+
                  |
                  v
        Attach README + files
                  |
                  v
          Result / Issue URL

The extension also provides supporting Redmine workflows including bulk README push, issue/project management, file attachment, time logging, assignment, history, settings, permissions-aware navigation, duplicate handling, and light/dark themes.

The project explicitly keeps AI generation outside the extension. The README is produced by the Claude skill or another workflow and then supplied to the extension as a file.

---

2. Jira Story Definition¶

User Story¶

As a Redmine user,
I want to select a generated project README/story from the Chrome extension, choose the appropriate Redmine project and issue operation, review the populated issue fields, preview the operation, and push it to Redmine,
so that project work documented in Markdown can be converted into a Redmine issue without manually copying the story into Redmine.

Story Type¶

Feature

Primary Deliverable¶

A Chrome extension that provides a controlled README-to-Redmine story creation workflow.

Primary Users¶

User	Expected Use
Redmine Administrator	Create projects, push stories, bulk push, manage issues/files, assign users, log time
Standard Redmine User	Push stories into assigned projects where their Redmine role permits the action
Documentation / Development User	Select generated README files and convert them into Redmine issues/sub-tasks/updates

---

3. Business / User Requirement¶

#	Requirement	Description	Status
1	README selection	Discover and select generated README/story files	Implemented
2	Project selection	Choose an existing Redmine project; administrators may create a new project	Implemented
3	Story creation	Create a new top-level Redmine issue from a README	Implemented
4	Sub-task creation	Create a README as a sub-task under an existing issue	Implemented
5	Existing issue update	Add a dated update/note and versioned README to an existing issue	Implemented
6	Field autofill	Populate subject, tracker, priority, assignee and date/estimate fields from available metadata/defaults	Implemented
7	Preview	Validate the intended operation without sending it to Redmine	Implemented
8	Duplicate protection	Ask Redmine whether the README/files already exist before pushing	Implemented
9	Companion files	Push files associated with a README to the same issue	Implemented
10	Bulk story creation	Push multiple READMEs in one operation	Implemented
11	Permissions-aware UI	Show only actions/projects allowed by the signed-in Redmine account	Implemented
12	Result feedback	Show created/skipped/failed results and the resulting Redmine issue information	Implemented
13	History	Maintain local push history and reconcile it with Redmine	Implemented
14	Redmine management	Provide issue/project/file management functions from the extension	Implemented
15	AI integration inside extension	Generate README content or scrape AI chat pages	Out of Scope

---

4. Problem Statement¶

Before the extension workflow, a generated project story existed as a Markdown document but required manual Redmine entry.

Typical manual flow:

AI / Documentation Workflow
        |
        v
README.md generated
        |
        v
Open Redmine
        |
        v
Find project
        |
        v
Create issue
        |
        v
Copy subject
        |
        v
Copy README description
        |
        v
Add attachments
        |
        v
Select tracker / priority / assignee / dates
        |
        v
Submit issue

This creates several practical problems:

• repeated manual copying of story content;
• risk of selecting the wrong project;
• inconsistent issue metadata;
• repeated work when a story already exists;
• difficulty handling multiple READMEs;
• no controlled dry-run before creating the issue;
• no integrated handling of README companion files;
• no consistent update/sub-task workflow;
• permission handling could become disconnected from actual Redmine access;
• a generated README and the Redmine issue could become difficult to reconcile.

The extension addresses the workflow problem without moving AI generation into the browser extension.

---

5. Objectives¶

1. Provide a focused Chrome UI for README-to-Redmine story creation.
2. Allow users to create new issues, sub-tasks, or updates from a README.
3. Reuse README metadata and Redmine data to reduce manual field entry.
4. Respect the signed-in user's actual Redmine permissions.
5. Provide a dry-run/preview before a real push.
6. Detect duplicate content before creating another issue.
7. Keep README companion files attached to the same story.
8. Support both individual and bulk story creation.
9. Provide clear success, warning, duplicate, and failure states.
10. Keep AI/chat integration outside the extension for portability and reduced coupling.

---

6. Scope¶

In Scope¶

• Chrome Manifest V3 extension.
• README discovery and selection.
• README preview.
• Existing project selection.
• Administrator-only new project flow.
• New issue creation.
• Sub-task creation.
• Existing issue update.
• Subject, tracker, priority, assignee, start date, due date and estimated-hours fields.
• Project and issue suggestions.
• Dry-run preview.
• Duplicate detection and Push Anyway handling.
• README companion file selection.
• Single README push.
• Bulk README push.
• Redmine-aware permission/capability UI.
• Push result display.
• Manage tab.
• Issue/project/file download and attachment workflows.
• Assign workflow where Redmine permits it.
• Time logging where Redmine permits it.
• Push history.
• Settings and theme controls.
• Session-aware sign-in/sign-out UI.
• Backend API communication.

Out of Scope¶

• AI/LLM calls from the extension.
• Generating README content inside the extension.
• Scraping Claude, ChatGPT, Gemini, or other chat pages.
• Storing Redmine passwords in the extension.
• Storing the Redmine API key in the extension.
• Replacing Redmine's permission enforcement.

Future / External Dependencies¶

• The backend must remain available for API operations.
• Redmine REST API must be enabled.
• The README/story-generation workflow must produce the expected Markdown files and metadata.
• Shared-server deployment requires appropriate HTTPS/reverse-proxy configuration.

---

7. Current System / Existing Flow¶

The current architecture deliberately separates story generation from story submission.

flowchart LR
    A["AI Chat / Project Work"] --> B["Claude Skill or Other Documentation Workflow"]
    B --> C["README.md + Companion Files"]
    C --> D["Local README Folder / Extension File Input"]
    D --> E["Chrome Extension"]
    E --> F["FastAPI Backend"]
    F --> G["Redmine REST API"]
    G --> H["Issue / Sub-task / Update"]

The extension does not need to know which AI tool generated the README.

This makes the workflow compatible with:

• Claude;
• ChatGPT;
• Gemini;
• manually created Markdown;
• other documentation generators.

---

8. Proposed / Implemented Solution¶

8.1 Extension Technology¶

Component	Implementation
Browser	Google Chrome
Extension standard	Manifest V3
Language	JavaScript
UI	HTML + CSS + dependency-free JavaScript
Build system	No Node/npm build step
Client storage	Chrome storage.local
Backend communication	Fetch / REST API
Browser permissions	activeTab, storage, localhost plus optional HTTP/HTTPS origin access
Minimum Chrome version	110
Extension version in supplied implementation	4.0.0

8.2 Main Extension Modules¶

extension/
├── manifest.json
├── popup.html
├── popup.js
├── popup.css
├── api.js
├── login.js
├── state.js
├── ui.js
├── bulk.js
├── theme.js
├── theme-init.js
└── icons/

8.3 Responsibility Split¶

File	Responsibility
manifest.json	Manifest V3 configuration, permissions, popup and icons
popup.html	Extension UI structure and views
popup.js	Main application orchestration, selection, rendering, push flow, manage/history/time workflows
api.js	Backend REST client, authentication/session handling, API errors, file downloads
login.js	Backend address, Redmine username/password sign-in and connection probe
state.js	Shared application state and capability checks
bulk.js	Multiple README queue, validation, progress and batch push
ui.js	Safe DOM helpers, notifications, icons, Markdown/file helpers
theme.js	Theme handling
theme-init.js	Early theme initialization
popup.css	Extension visual design and responsive state styling

---

9. Architecture¶

flowchart TB
    U["User"] --> X["Chrome Extension"]

    subgraph EXT["Chrome Extension - Manifest V3"]
        P["popup.html"]
        JS["popup.js"]
        API["api.js"]
        LOGIN["login.js"]
        STATE["state.js"]
        BULK["bulk.js"]
        UI["ui.js"]
        THEME["theme.js / theme-init.js"]

        P --> JS
        JS --> STATE
        JS --> API
        JS --> BULK
        JS --> UI
        LOGIN --> API
        THEME --> P
    end

    X --> EXT
    API --> B["FastAPI Backend"]

    subgraph BACK["Backend"]
        AUTH["Authentication / Session"]
        FILES["README/File Services"]
        PUSH["Push Services"]
        RM["Redmine Client"]
        DB["SQLite History / Mapping"]
    end

    B --> AUTH
    B --> FILES
    B --> PUSH
    B --> RM
    B --> DB

    RM --> R["Redmine REST API"]

Architectural Principle¶

The extension is a client, not the system of record.

• Redmine remains the authority for projects, issues and permissions.
• The backend remains the authority for session/API interaction.
• The local README is the source document for the story.
• The extension controls user interaction and submission choices.

---

10. End-to-End Workflow¶

10.1 Sign-in¶

sequenceDiagram
    participant U as User
    participant E as Extension
    participant B as Backend
    participant R as Redmine

    U->>E: Enter backend URL
    U->>E: Enter Redmine username/password
    E->>B: POST /auth/login
    B->>R: Validate credentials
    R-->>B: User + permissions + API identity
    B-->>E: Session token + capabilities
    E->>E: Store session metadata
    E-->>U: Open application

The extension does not retain the password after sign-in and does not receive the Redmine API key.

10.2 Single Story Creation¶

flowchart TD
    A["Open Extension"] --> B["Select README"]
    B --> C["Load project / issue suggestions"]
    C --> D["Choose Project"]
    D --> E{"Issue Operation"}
    E -->|New| F["Create Top-Level Issue"]
    E -->|Sub-task| G["Select Parent Issue"]
    E -->|Update| H["Select Existing Issue"]
    F --> I["Review Fields"]
    G --> I
    H --> I
    I --> J["Preview / Dry Run"]
    J --> K{"Duplicate?"}
    K -->|No| L["Push"]
    K -->|Yes| M["Review Existing Redmine Location"]
    M --> N{"Push Anyway?"}
    N -->|No| O["Stop"]
    N -->|Yes| L
    L --> P["Backend"]
    P --> Q["Redmine"]
    Q --> R["Result / Issue"]

10.3 Bulk Story Creation¶

flowchart LR
    A["Select Many READMEs"] --> B["Queue"]
    B --> C["Choose Project"]
    C --> D["Optional Shared Fields"]
    D --> E["Validate / Dry Run"]
    E --> F["Push in Batches"]
    F --> G["Per-file Result"]
    G --> H["Created"]
    G --> I["Skipped / Duplicate"]
    G --> J["Failed"]
    G --> K["Unsent"]

---

11. Detailed Technical Logic¶

11.1 README Discovery and Selection¶

The extension requests README metadata from the backend.

The selection logic supports:

• newest unpushed README selection;
• explicit file selection;
• rescanning;
• removing a README from the visible list;
• restoring removed README entries;
• README preview;
• pushed/new/older status indicators;
• companion-file count;
• front-matter indication.

The extension sends opaque file IDs to the backend rather than arbitrary filesystem paths.

11.2 Chat Association¶

The extension does not scrape a chat page.

When chat remembering is enabled:

1. It reads the active tab URL/title using activeTab.
2. It checks whether the URL contains a stable chat-like identifier.
3. It creates a one-way SHA-1-derived chat key from the tab origin/path.
4. Only that opaque key and cleaned title are used for backend suggestion/history association.
5. A new-chat page without a stable identity is not remembered.

This allows project/story associations to persist without granting the extension content-script access to AI websites.

11.3 Project Suggestion¶

The backend can provide project suggestions.

The extension supports:

• existing project selection;
• administrator new-project selection;
• project search/filter;
• project metadata loading;
• project permission filtering.

For non-administrators, the UI uses My projects and does not expose the new-project option.

11.4 Issue Modes¶

The extension provides three issue modes:

Mode	Behaviour
New issue	Creates a new top-level Redmine issue
Sub-task	Creates the story below a selected parent issue
Update	Updates an existing issue with a dated note/versioned README

A new project can start with a new issue. Sub-task and update operations require an existing project.

11.5 Field Autofill¶

The extension displays and allows editing of:

• Subject;
• Tracker;
• Priority;
• Assignee;
• Start date;
• Due date;
• Estimated hours.

Values can come from:

1. README front matter;
2. project/application defaults;
3. Redmine defaults.

User-edited fields are preserved instead of being silently overwritten by later suggestion refreshes.

11.6 Parent Issue Selection¶

For sub-task creation, the extension loads issues for the selected project and lets the user search/select the parent.

The selected parent is sent as parent_id.

11.7 Existing Issue Update¶

Update mode targets an existing issue.

The update operation is designed to preserve the story history by adding a dated note and attaching a versioned README rather than treating every README revision as a completely unrelated story.

11.8 Preview / Dry Run¶

Before a real push, the extension can send a dry-run request.

Purpose:

• validate project selection;
• validate issue mode;
• validate metadata;
• detect duplicate content;
• expose likely errors before creating/updating Redmine data.

The preview does not perform the final Redmine write.

11.9 Duplicate Detection¶

Duplicate checking is performed against Redmine-backed content rather than relying only on local extension history.

The README and companion files can be compared against content already associated with the target project.

If a duplicate is detected:

Existing Redmine Content
        |
        v
Extension warning
        |
        +--> Review existing issue/file
        |
        +--> Do not push
        |
        +--> Push anyway

The extension exposes a controlled Push anyway path rather than silently creating duplicate content.

11.10 Companion Files¶

A README can have related files such as:

• screenshots;
• PDFs;
• spreadsheets;
• source files;
• test reports;
• diagrams;
• data files.

The extension can:

• detect files associated with a README;
• show them in the attachment area;
• allow individual files to be excluded;
• add additional files;
• send selected files with the README.

Files are intended to travel with the same Redmine issue.

11.11 Bulk Push¶

Bulk mode supports multiple READMEs in one workflow.

The supplied implementation supports up to 50 READMEs per bulk operation.

The UI provides:

• drag/drop or file picker;
• queue management;
• per-file status;
• shared project selection;
• optional shared tracker/priority/assignee fields;
• dry-run validation;
• progress bar;
• batch processing;
• individual created/skipped/failed/unsent results;
• retry of failed items;
• duplicate override for skipped duplicate items.

A failed file does not inherently invalidate the successful files in the same batch.

---

12. Data Flow¶

Single Story¶

README
  |
  | file ID / metadata
  v
Extension State
  |
  | project + issue + fields + attachments
  v
buildRequest()
  |
  v
POST /push
  |
  v
Backend
  |
  v
Redmine
  |
  +--> Issue
  +--> Description / note
  +--> README attachment
  +--> Companion attachments
  |
  v
Result
  |
  v
Extension Result View

Bulk Story Creation¶

README 1 ─┐
README 2 ─┤
README 3 ─┤
...       ├──> Bulk Queue ──> Validation ──> /push/bulk ──> Redmine
README N ─┘                                      |
                                                 v
                                      Per-file result state

Backend API Contract Used by the Extension¶

Core endpoints include:

Endpoint	Extension purpose
POST /auth/login	Sign in
POST /auth/logout	Sign out
GET /auth/me	Restore/check session
GET /files	Discover README files
GET /files/{id}	Read README preview
GET /suggest	Obtain project/issue/default suggestions
GET /projects	Load Redmine-visible projects
GET /trackers	Load trackers
GET /priorities	Load priorities
GET /projects/{id}/meta	Load project metadata/members
GET /issues	Load issues for parent/update selection
POST /push	Single story push
POST /push/bulk	Bulk story push
GET /history	Load push history
DELETE /history	Remove local history entries
GET /manage/projects/{id}/issues	Manage issue listing
GET /manage/issues/{id}	Read issue details
PUT /manage/issues/{id}	Update issue
GET /manage/issues/{id}/download	Download issue package
POST /manage/export	Export project issues
POST /manage/attachments	Attach file
POST /time-entries	Log time

---

13. Key Functional Behaviour¶

13.1 Permission-Aware Navigation¶

The extension derives visible capabilities from the authenticated account.

Examples:

push_readme
bulk_push
assign_members
create_users
log_time
view_history
edit_project
upload_project_files
create_project

The UI hides or disables functions when the backend reports that the user does not have the corresponding capability.

Redmine remains the final authority and can still reject an operation.

13.2 My Projects Rule¶

For non-administrators:

Redmine Memberships
        |
        v
My Projects
        |
        +--> Push
        +--> Bulk Push
        +--> Manage
        +--> Log Time

The extension does not expose an unrestricted all-project picker to standard users.

13.3 Administrator Behaviour¶

Administrators can work across projects and have additional project/user management functions where supported by Redmine.

The extension does not implement a separate application-level administrator database.

13.4 Result Handling¶

A successful push displays information such as:

• issue number;
• issue URL;
• push timestamp;
• result status;
• warnings, when applicable.

Bulk mode displays each file's individual result.

13.5 Local History¶

The History tab records push activity and allows local history entries to be removed.

Deleting extension history does not delete the Redmine issue.

History is reconciled against Redmine so an issue that no longer exists can be identified as no longer present in Redmine.

13.6 Manage Workflow¶

The Manage tab provides Redmine-oriented operations including:

• project selection;
• project issue search/listing;
• issue inspection;
• issue update;
• issue download;
• project export;
• file attachment;
• project file management where permitted.

13.7 Time Logging¶

Where the signed-in Redmine account can log time, the extension supports:

• project selection;
• issue/project target;
• activity selection;
• hours;
• spent-on date;
• comments.

13.8 Assignment¶

Where Redmine permits it, the extension supports assigning users to projects and creating users through the administrator workflow.

---

14. Edge Cases & Error Handling¶

14.1 Backend Unavailable¶

The extension reports that the backend cannot be reached instead of silently failing.

14.2 Session Expired¶

Unauthorized responses trigger local session handling and return the user to the sign-in state.

14.3 Invalid Backend URL¶

The login UI validates the backend address and reports invalid URLs.

14.4 Insecure Remote HTTP¶

For non-local HTTP backend addresses, the extension warns that credentials would cross the network without encryption.

Shared-server deployments should use HTTPS.

14.5 Permission Denied¶

The extension shows backend/Redmine permission errors and does not attempt to bypass Redmine authorization.

14.6 Duplicate README/File¶

The extension shows the existing Redmine location and requires an explicit Push Anyway decision before forcing the duplicate.

14.7 Missing Project¶

The push validation prevents submission until an appropriate project is selected.

14.8 Missing Parent¶

Sub-task/update operations require an appropriate target issue.

14.9 Invalid Dates¶

The extension validates the relationship between start and due dates.

14.10 Bulk Failure¶

Bulk operations track per-file state:

created
skipped
failed
unsent
dry_run
sending

This allows individual failures to be identified and retried rather than treating the whole queue as an opaque transaction.

14.11 Large README¶

If the Redmine description size is exceeded, the backend can fall back to a summary description while retaining the complete README as an attachment.

---

15. Configuration / Dependencies¶

Browser¶

• Google Chrome.
• Manifest V3 support.
• Minimum Chrome version: 110.

Backend¶

The extension requires the FastAPI backend to be running.

Development startup:

cd backend
python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -r requirements.txt
python run.py check
python run.py

Extension Loading¶

Chrome
  |
  v
chrome://extensions
  |
  v
Developer Mode
  |
  v
Load unpacked
  |
  v
Select:
redmine-ai-automation/extension

Backend Address¶

Default development address:

http://localhost:8000

The extension can request optional origin permission for a remote backend address.

Redmine¶

The backend requires Redmine REST API access.

The extension signs the user in through the backend using the user's Redmine credentials.

Client-Side Storage¶

Chrome extension storage holds:

• backend URL;
• session metadata;
• account/capability metadata;
• last username;
• UI preferences;
• chat association preference;
• recent-minute setting;
• local dismissed-file state;
• theme preference.

The Redmine API key is not sent to or stored by the extension.

---

16. Testing & Verification¶

Verified Implementation Areas From the Supplied Project¶

The supplied source contains implementation for:

• Manifest V3 extension loading;
• login and session flow;
• permission-aware capability handling;
• README discovery;
• README preview;
• project suggestions;
• issue selection;
• new issue/sub-task/update modes;
• field autofill;
• dry-run preview;
• duplicate detection;
• companion-file handling;
• bulk push;
• history;
• Manage workflow;
• time logging;
• assignment workflow;
• theme switching;
• error handling.

Manual Verification Checklist¶

#	Test	Expected Result
1	Load unpacked extension	Extension loads without manifest error
2	Start backend	Extension can reach backend
3	Sign in with valid Redmine account	Session established
4	Sign in with invalid credentials	Error shown; password cleared
5	Select README	README preview and metadata appear
6	Choose project	Project selection is reflected in summary
7	Choose New issue	Issue fields become available
8	Choose Sub-task	Parent issue selector appears
9	Choose Update	Existing issue selector is used
10	Change tracker/priority/assignee	User changes are retained
11	Preview	Validation occurs without final push
12	Push valid README	Redmine issue is created/updated
13	Push duplicate README	Duplicate warning is shown
14	Push Anyway	Explicit duplicate override is required
15	Attach companion file	File travels with story
16	Bulk validate	No Redmine writes occur
17	Bulk push	Individual result states are displayed
18	Remove history	Local history changes only
19	Log time	Redmine time entry is created when permitted
20	Standard user	Only allowed projects/actions are presented
21	Administrator	Administrative capabilities are presented
22	Session expiry	User is returned to sign-in
23	Dark mode	Theme preference is applied and remembered

Testing Status Classification¶

The supplied project contains implementation and documentation for the above behaviours. This story does not claim a fresh execution of every test case unless an actual test result is separately recorded.

---

17. Current Status¶

Implementation status: Implemented in the supplied Redmine README Sync v4 extension.

The extension source contains the complete client-side workflow for README-based Redmine story creation plus the supporting management workflows.

The supplied implementation identifies the extension as:

Name: Redmine README Sync
Version: 4.0.0
Manifest: Manifest V3
Minimum Chrome: 110

The extension is designed to operate against the accompanying FastAPI backend and Redmine REST API.

---

18. Known Limitations¶

1. The extension itself does not generate README/story content.
2. The extension does not call an AI API.
3. The extension does not scrape chat pages.
4. The backend must be available for Redmine operations.
5. Redmine REST API must be enabled.
6. Shared-server deployments require HTTPS because Redmine credentials are submitted during sign-in.
7. A new-chat page without a stable conversation identifier cannot be associated with remembered chat state.
8. Redmine remains authoritative for final permission enforcement.
9. Large Redmine projects may use bounded duplicate-search behaviour rather than an unlimited issue scan.
10. Fresh end-to-end execution of every documented test case is not claimed by this story unless separately recorded.

---

19. Decisions & Important Design Notes¶

19.1 No AI Inside the Extension¶

The extension was intentionally separated from AI generation.

AI / Claude Skill
       |
       v
README.md
       |
       v
Extension
       |
       v
Redmine

This prevents the extension from being coupled to a particular AI website or API.

19.2 No Chat Content Scraping¶

Only the active tab URL/title can be used for optional chat association.

The extension does not inject scripts into Claude or other chat websites.

19.3 Redmine Is the Permission Authority¶

Application-level capability visibility improves UX, but Redmine remains the enforcement layer.

19.4 Explicit Duplicate Override¶

Duplicate content is not silently pushed.

The user must explicitly choose the override path.

19.5 User-Controlled Project Selection¶

For standard users, project selection is limited to assigned projects.

19.6 Dry Run Before Write¶

The extension provides a preview/validation stage before the actual Redmine write operation.

19.7 Stable Story Identity¶

The README-generation skill supplies stable story_key metadata so repeated generation of the same logical story can be mapped back to the same Redmine work item rather than being treated as a completely new story.

---

20. Future Enhancements / Next Steps¶

Only items supported by the existing project direction are listed here:

• Continue extending Redmine-native management capabilities as required.
• Maintain compatibility between README front matter and extension autofill logic.
• Expand automated browser-level regression coverage for the extension UI.
• Continue validating bulk push and duplicate workflows against representative Redmine datasets.
• Maintain compatibility with future Redmine API/configuration changes.
• Continue improving deployment and operational diagnostics for shared-server installations.

---

21. Final Outcome¶

The extension provides a complete user-facing bridge between generated Markdown project documentation and Redmine story management.

The resulting workflow is:

┌───────────────────────────┐
│ Project / AI Conversation │
└─────────────┬─────────────┘
              │
              v
┌───────────────────────────┐
│ README / Story Generation │
│ Claude Skill / Other Tool │
└─────────────┬─────────────┘
              │
              v
┌───────────────────────────┐
│ Chrome Extension          │
│                           │
│ 1. Select README          │
│ 2. Select Project         │
│ 3. Select Issue Operation │
│ 4. Review Fields          │
│ 5. Preview                │
│ 6. Push                   │
└─────────────┬─────────────┘
              │
              v
┌───────────────────────────┐
│ FastAPI Backend           │
│ Session + Validation      │
│ Redmine API Client        │
└─────────────┬─────────────┘
              │
              v
┌───────────────────────────┐
│ Redmine                   │
│                           │
│ Issue / Sub-task / Update │
│ + README + Attachments    │
└───────────────────────────┘

The extension therefore turns the README produced by the project-documentation workflow into an actionable Redmine story while keeping story generation, browser UI, backend security, and Redmine authorization as separate responsibilities.

---

22. Reference / Execution Information¶

Project¶

redmine-ai-automation

Extension Location¶

redmine-ai-automation/extension/

Important Source Files¶

extension/manifest.json
extension/popup.html
extension/popup.js
extension/popup.css
extension/api.js
extension/login.js
extension/state.js
extension/bulk.js
extension/ui.js
extension/theme.js
extension/theme-init.js

Backend Dependency¶

redmine-ai-automation/backend/

Key Backend APIs Used for Story Creation¶

POST /auth/login
GET  /auth/me
GET  /files
GET  /files/{id}
GET  /suggest
GET  /projects
GET  /trackers
GET  /priorities
GET  /projects/{id}/meta
GET  /issues
POST /push
POST /push/bulk
GET  /history

Setup Reference¶

1. Create and activate the Python virtual environment.
2. Install backend requirements.
3. Configure backend/config.yaml.
4. Run: python run.py check
5. Run: python run.py
6. Open chrome://extensions.
7. Enable Developer Mode.
8. Select Load unpacked.
9. Select the framework's extension folder.
10. Ensure Redmine is running.
11. Sign in through the extension using the Redmine account.

Source Basis¶

This story was prepared from the supplied redmine-ai-automation framework, its extension source, backend API contract, project documentation, the supplied Redmine setup guideline, and the previously established project requirements.

The implementation should be treated as the authoritative source for what is actually present in the supplied framework; planned or unverified behaviour is explicitly identified rather than presented as a completed test result.