@getdevintern/pm 1.0.0

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@getdevintern/pm",
+  "version": "1.0.0",
+  "description": "Automate story and task creation across multiple project management tools with AI. Transform Figma designs, error logs, or requirements into well-structured issues using your preferred AI agent.",
+  "type": "module",
+  "bin": {
+    "devpm": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "prompts",
+    "README.md",
+    "LICENSE.md",
+    ".env.example"
+  ],
+  "scripts": {
+    "build": "bun build index.ts --target=bun --outdir=dist --format=esm --external=ink --external=react --external=ink-scroll-view --minify && bun run tsc --noEmit",
+    "format": "oxfmt \"index.ts\" \"lib/**/*.ts\" \"lib/**/*.tsx\" \"*.test.ts\"",
+    "format:check": "oxfmt --check \"index.ts\" \"lib/**/*.ts\" \"lib/**/*.tsx\" \"*.test.ts\"",
+    "lint": "oxlint .",
+    "install-global": "bun run build && bun link",
+    "uninstall-global": "bun unlink",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "jira",
+    "claude",
+    "opencode",
+    "ai",
+    "project-management",
+    "figma",
+    "automation",
+    "cli",
+    "task-management"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/danii1/devintern.git",
+    "directory": "packages/pm"
+  },
+  "bugs": {
+    "url": "https://github.com/danii1/devintern/issues"
+  },
+  "homepage": "https://devintern.com",
+  "author": "Daniil",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@devintern/agent-harness": "workspace:*",
+    "@devintern/auth": "workspace:*",
+    "@devintern/license-check": "workspace:*",
+    "@devintern/text-formatter": "workspace:*",
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@types/react": "^19.2.7",
+    "ink": "^6.6.0",
+    "ink-scroll-view": "^0.3.2",
+    "ink-text-input": "^6.0.0",
+    "react": "19.2.5"
+  }
+}

package/prompts/figma/pm/decomposition.txt

@@ -0,0 +1,38 @@
+Decompose the following Jira story into smaller, actionable tasks with detailed descriptions. Don't be very technical, you are business/product person
+
+Story: {{storySummary}}
+
+Description:
+{{storyDescription}}
+
+IMPORTANT:
+- Implementation should use the existing design system. DO NOT include specific design notes, colors, fonts, or styling details from Figma. Focus on functionality and behavior.
+- Suggest reusing or adapting existing code rather than building everything from scratch
+
+Requirements for each task:
+- Focused on a single responsibility
+- Completable within 1-2 days
+- Not too granular (group similar small tasks together)
+- Not too large (break down complex work)
+- MUST include a detailed description formatted in MARKDOWN with:
+  * Use ## for section headers (e.g., "## What needs to be done", "## Acceptance Criteria")
+  * Use - for bullet points
+  * Use **text** for important terms or emphasis
+  * Use `code` for technical terms, function names, or code references
+  * Clear sections explaining functionality (not design specifics)
+
+Return your response ONLY as valid JSON in this exact format (no markdown, no code blocks, no additional text):
+
+{
+  "subtasks": [
+    {
+      "summary": "Brief, actionable task title",
+      "description": "## What needs to be done\\n\\nDetailed explanation...\\n\\n## Acceptance Criteria\\n\\n- Criterion 1\\n- Criterion 2"
+    }
+  ]
+}
+
+IMPORTANT:
+- Each task MUST have a comprehensive description
+- Format descriptions using MARKDOWN (headers, bullets, bold, code)
+- This ensures proper formatting in Jira

package/prompts/figma/pm/story-generation.txt

@@ -0,0 +1,21 @@
+Analyze the following Figma design and generate PM-style requirements for a Jira story, don't be very technical, you are business/product person:
+
+{{figmaUrl}}
+{{epicContext}}
+{{extraInstructions}}
+
+IMPORTANT:
+- Implementation should use the existing design system. DO NOT include specific design notes or styling details from Figma.
+- Suggest reusing or adapting existing code rather than building everything from scratch.
+
+Please analyze the Figma design and provide the requirements in the following JSON format with MARKDOWN formatting:
+
+{
+  "summary": "Brief, clear title for the story",
+  "description": "## User Story\\n\\nAs a [user type]\\nI want [goal]\\nSo that [benefit]\\n\\n## Design Reference\\n\\n{{figmaUrl}}\\n\\n## Acceptance Criteria\\n\\n- Criterion 1\\n- Criterion 2\\n- Criterion 3\\n\\n**Note:** Implementation must use existing design system components and patterns, not Figma-specific styling."
+}
+
+IMPORTANT:
+- Format the description using MARKDOWN (## headers, - bullets, **bold**, `code`)
+- This ensures proper rich formatting in Jira
+- Return ONLY valid JSON, no additional text

package/prompts/figma/technical/decomposition.txt

@@ -0,0 +1,45 @@
+Decompose the following Jira story into smaller, actionable tasks with detailed descriptions.
+
+Story: {{storySummary}}
+
+Description:
+{{storyDescription}}
+
+IMPORTANT:
+- Implementation should use the existing design system. DO NOT include specific design notes, colors, fonts, or styling details from Figma. Focus on functionality and behavior.
+- BEFORE creating subtasks, explore the current codebase to identify existing code that can be reused:
+  * Check for existing API endpoints and client methods that could be used or extended
+  * Look for similar UI components that can be adapted or reused
+  * Review existing screens/pages for similar patterns and implementations
+  * Search for Redux actions, reducers, selectors that might be relevant or reusable
+  * Identify utility functions, hooks, and helpers that could be leveraged
+- When creating subtasks, reference specific existing code files, components, functions, or patterns
+- Suggest reusing or adapting existing code rather than building everything from scratch
+
+Requirements for each task:
+- Focused on a single responsibility
+- Completable within 1-2 days
+- Not too granular (group similar small tasks together)
+- Not too large (break down complex work)
+- MUST include a detailed description formatted in MARKDOWN with:
+  * Use ## for section headers (e.g., "## What needs to be done", "## Acceptance Criteria", "## Technical Considerations")
+  * Use - for bullet points
+  * Use **text** for important terms or emphasis
+  * Use `code` for technical terms, function names, or code references
+  * Clear sections explaining functionality (not design specifics)
+
+Return your response ONLY as valid JSON in this exact format (no markdown, no code blocks, no additional text):
+
+{
+  "subtasks": [
+    {
+      "summary": "Brief, actionable task title",
+      "description": "## What needs to be done\\n\\nDetailed explanation...\\n\\n## Acceptance Criteria\\n\\n- Criterion 1\\n- Criterion 2\\n\\n## Technical Considerations\\n\\n- Use existing **design system** components (e.g., `Button`, `Dialog`, `Input`)\\n- Leverage `apiClient.updateBrief()` or similar existing API methods\\n- Follow patterns from `src/screens/ExistingScreen.tsx`\\n- Reuse `useBriefState` hook or similar existing hooks\\n- Consider existing Redux actions like `updateBriefAction`"
+    }
+  ]
+}
+
+IMPORTANT:
+- Each task MUST have a comprehensive description
+- Format descriptions using MARKDOWN (headers, bullets, bold, code)
+- This ensures proper formatting in Jira

package/prompts/figma/technical/story-generation.txt

@@ -0,0 +1,27 @@
+Analyze the following Figma design and generate PM-style requirements for a Jira story:
+
+{{figmaUrl}}
+{{epicContext}}
+{{extraInstructions}}
+
+IMPORTANT:
+- Implementation should use the existing design system. DO NOT include specific design notes or styling details from Figma.
+- BEFORE creating requirements, explore the current codebase to identify existing code that can be reused:
+  * Check for existing API endpoints and client methods
+  * Look for similar UI components that can be adapted
+  * Review existing screens/pages for similar patterns
+  * Search for Redux actions, reducers, selectors that might be relevant
+  * Identify utility functions that could be leveraged
+- Reference specific existing code in your requirements when applicable
+
+Please analyze the Figma design and provide the requirements in the following JSON format with MARKDOWN formatting:
+
+{
+  "summary": "Brief, clear title for the story",
+  "description": "## User Story\\n\\nAs a [user type]\\nI want [goal]\\nSo that [benefit]\\n\\n## Design Reference\\n\\n{{figmaUrl}}\\n\\n## Acceptance Criteria\\n\\n- Criterion 1\\n- Criterion 2\\n- Criterion 3\\n\\n## Technical Considerations\\n\\n- Use existing **design system** components\\n- Leverage existing `ApiClient` methods or similar patterns\\n- Reuse `ExistingComponent` or adapt similar UI patterns\\n- Follow existing Redux patterns (e.g., `existingActions`, `existingSelectors`)\\n- Consider existing utility functions in `@/utils`\\n\\n**Note:** Implementation must use existing design system components and patterns, not Figma-specific styling."
+}
+
+IMPORTANT:
+- Format the description using MARKDOWN (## headers, - bullets, **bold**, `code`)
+- This ensures proper rich formatting in Jira
+- Return ONLY valid JSON, no additional text

package/prompts/log/pm/decomposition.txt

@@ -0,0 +1,38 @@
+Decompose the following bug fix story into smaller, actionable tasks with detailed descriptions:
+
+Story: {{storySummary}}
+
+Description:
+{{storyDescription}}
+
+IMPORTANT:
+- Focus on investigation, fix, testing, and validation tasks
+- Suggest checking existing error handling patterns
+- Consider both immediate fix and preventive measures
+
+Requirements for each task:
+- Focused on a single responsibility
+- Completable within 1-2 days
+- Not too granular (group similar small tasks together)
+- Not too large (break down complex work)
+- MUST include a detailed description formatted in MARKDOWN with:
+  * Use ## for section headers (e.g., "## What needs to be done", "## Acceptance Criteria")
+  * Use - for bullet points
+  * Use **text** for important terms or emphasis
+  * Use `code` for technical terms, function names, or code references
+
+Return your response ONLY as valid JSON in this exact format (no markdown, no code blocks, no additional text):
+
+{
+  "subtasks": [
+    {
+      "summary": "Brief, actionable task title",
+      "description": "## What needs to be done\\n\\nDetailed explanation...\\n\\n## Acceptance Criteria\\n\\n- Criterion 1\\n- Criterion 2"
+    }
+  ]
+}
+
+IMPORTANT:
+- Each task MUST have a comprehensive description
+- Format descriptions using MARKDOWN (headers, bullets, bold, code)
+- This ensures proper formatting in Jira

package/prompts/log/pm/story-generation.txt

@@ -0,0 +1,23 @@
+Analyze the following error log or bug report and generate PM-style requirements for a Jira story to fix the issue:
+
+{{logContent}}
+{{epicContext}}
+{{extraInstructions}}
+
+IMPORTANT:
+- Focus on the user impact and business value of fixing this issue
+- Describe the problem from a user perspective
+- Avoid overly technical implementation details
+- Suggest investigating existing code and patterns for the fix
+
+Please analyze the log/error and provide the requirements in the following JSON format with MARKDOWN formatting:
+
+{
+  "summary": "Brief, clear title describing the bug or issue",
+  "description": "## Problem Description\\n\\nClear explanation of what's broken from user perspective\\n\\n## Error Details\\n\\n```\\n{{logContent}}\\n```\\n\\n## Expected Behavior\\n\\n- What should happen\\n\\n## Actual Behavior\\n\\n- What currently happens\\n\\n## User Impact\\n\\n- Who is affected\\n- Severity and frequency\\n\\n## Acceptance Criteria\\n\\n- Issue is resolved\\n- No regression in related functionality\\n- Error handling is improved"
+}
+
+IMPORTANT:
+- Format the description using MARKDOWN (## headers, - bullets, **bold**, `code`, ``` code blocks)
+- This ensures proper rich formatting in Jira
+- Return ONLY valid JSON, no additional text

package/prompts/log/technical/decomposition.txt

@@ -0,0 +1,41 @@
+Decompose the following bug fix story into smaller, actionable technical tasks with detailed descriptions:
+
+Story: {{storySummary}}
+
+Description:
+{{storyDescription}}
+
+IMPORTANT:
+- Include investigation, debugging, implementation, testing, and monitoring tasks
+- Suggest checking existing error handling patterns and recovery mechanisms
+- Consider both immediate fix and preventive measures
+- Include technical debt reduction opportunities
+
+Requirements for each task:
+- Focused on a single responsibility
+- Completable within 1-2 days
+- Not too granular (group similar small tasks together)
+- Not too large (break down complex work)
+- MUST include a detailed description formatted in MARKDOWN with:
+  * Use ## for section headers (e.g., "## What needs to be done", "## Technical Approach", "## Acceptance Criteria")
+  * Use - for bullet points
+  * Use **text** for important terms or emphasis
+  * Use `code` for technical terms, function names, file paths, or code references
+  * Include technical context and implementation guidance
+
+Return your response ONLY as valid JSON in this exact format (no markdown, no code blocks, no additional text):
+
+{
+  "subtasks": [
+    {
+      "summary": "Brief, actionable task title",
+      "description": "## What needs to be done\\n\\nDetailed explanation...\\n\\n## Technical Approach\\n\\n- Implementation details\\n\\n## Acceptance Criteria\\n\\n- Criterion 1\\n- Criterion 2"
+    }
+  ]
+}
+
+IMPORTANT:
+- Each task MUST have a comprehensive description
+- Format descriptions using MARKDOWN (headers, bullets, bold, code)
+- Include specific technical guidance where helpful
+- This ensures proper formatting in Jira

package/prompts/log/technical/story-generation.txt

@@ -0,0 +1,23 @@
+Analyze the following error log or bug report and generate technical requirements for a Jira story to fix the issue:
+
+{{logContent}}
+{{epicContext}}
+{{extraInstructions}}
+
+IMPORTANT:
+- Provide technical analysis of the root cause
+- Include implementation approach and technical considerations
+- Suggest investigating existing error handling and recovery patterns
+- Consider architectural implications
+
+Please analyze the log/error and provide the requirements in the following JSON format with MARKDOWN formatting:
+
+{
+  "summary": "Brief, clear title describing the bug or issue",
+  "description": "## Problem Description\\n\\nClear explanation of what's broken\\n\\n## Error Details\\n\\n```\\n{{logContent}}\\n```\\n\\n## Root Cause Analysis\\n\\n- Potential causes based on the error\\n- Affected components/services\\n\\n## Expected Behavior\\n\\n- What should happen\\n\\n## Actual Behavior\\n\\n- What currently happens\\n\\n## User Impact\\n\\n- Who is affected\\n- Severity and frequency\\n\\n## Technical Considerations\\n\\n- Error handling approach\\n- Logging and monitoring improvements\\n- Testing strategy\\n- Potential side effects\\n\\n## Acceptance Criteria\\n\\n- Issue is resolved\\n- Error handling is improved\\n- Appropriate logging is in place\\n- Tests cover the fix\\n- No regression in related functionality"
+}
+
+IMPORTANT:
+- Format the description using MARKDOWN (## headers, - bullets, **bold**, `code`, ``` code blocks)
+- This ensures proper rich formatting in Jira
+- Return ONLY valid JSON, no additional text

package/prompts/prompt/pm/decomposition.txt

@@ -0,0 +1,30 @@
+Break down the following story into actionable subtasks:
+
+Story: {{storySummary}}
+
+Description:
+{{storyDescription}}
+
+IMPORTANT:
+- Create specific, actionable subtasks that can be worked on independently
+- Focus on user-facing deliverables and testable outcomes
+- Keep implementation details minimal - let developers determine the "how"
+- Suggest researching existing code patterns as part of the work
+- Each subtask should deliver incremental value
+- Order subtasks logically (research → design → build → test)
+
+Please provide subtasks in the following JSON format with MARKDOWN formatting:
+
+{
+  "subtasks": [
+    {
+      "summary": "Clear, action-oriented title",
+      "description": "## Goal\n\n[What needs to be achieved]\n\n## Details\n\n- Specific requirements\n- Expected outcomes\n\n## Acceptance\n\n- [ ] Deliverable is complete\n- [ ] Quality criteria met"
+    }
+  ]
+}
+
+IMPORTANT:
+- Format descriptions using MARKDOWN (## headers, - bullets, **bold**, `code`)
+- Each subtask should be completable in a reasonable timeframe
+- Return ONLY valid JSON, no additional text

package/prompts/prompt/pm/story-generation.txt

@@ -0,0 +1,24 @@
+Analyze the following requirement or feature description and generate PM-style requirements for a Jira story:
+
+{{promptContent}}
+{{epicContext}}
+{{extraInstructions}}
+
+IMPORTANT:
+- Focus on user value and business outcomes
+- Frame requirements from a user perspective
+- Keep technical implementation details minimal
+- Suggest investigating existing code and patterns when implementing
+- Create clear, actionable acceptance criteria
+
+Please analyze the requirement and provide it in the following JSON format with MARKDOWN formatting:
+
+{
+  "summary": "Brief, clear title for the story (user-facing benefit)",
+  "description": "## User Story\n\nAs a [user type], I want [goal] so that [benefit]\n\n## Background\n\n[Context and motivation for this feature]\n\n## Acceptance Criteria\n\n- [ ] Criterion 1\n- [ ] Criterion 2\n- [ ] Criterion 3\n\n## User Impact\n\n- Who benefits from this\n- Expected outcomes\n\n## Notes\n\n- Any additional considerations\n- Potential edge cases to consider"
+}
+
+IMPORTANT:
+- Format the description using MARKDOWN (## headers, - bullets, **bold**, `code`, ``` code blocks)
+- This ensures proper rich formatting in Jira
+- Return ONLY valid JSON, no additional text

package/prompts/prompt/technical/decomposition.txt

@@ -0,0 +1,31 @@
+Break down the following story into technical subtasks:
+
+Story: {{storySummary}}
+
+Description:
+{{storyDescription}}
+
+IMPORTANT:
+- Create specific, technical subtasks with clear deliverables
+- Include both implementation and testing tasks
+- Consider architecture, implementation, testing, and documentation
+- Suggest exploring existing codebase patterns first
+- Order tasks to minimize blockers (research → setup → implementation → testing)
+- Each subtask should be independently verifiable
+
+Please provide subtasks in the following JSON format with MARKDOWN formatting:
+
+{
+  "subtasks": [
+    {
+      "summary": "Clear, technical title indicating the deliverable",
+      "description": "## Objective\n\n[Technical goal of this task]\n\n## Technical Details\n\n- Implementation requirements\n- APIs/interfaces to create/modify\n- Dependencies and integration points\n\n## Testing\n\n- Unit tests needed\n- Integration test scenarios\n\n## Acceptance\n\n- [ ] Code complete and reviewed\n- [ ] Tests passing\n- [ ] Documentation updated"
+    }
+  ]
+}
+
+IMPORTANT:
+- Format descriptions using MARKDOWN (## headers, - bullets, **bold**, `code`, ``` code blocks)
+- Include both implementation and verification tasks
+- Each subtask should be completable independently where possible
+- Return ONLY valid JSON, no additional text

package/prompts/prompt/technical/story-generation.txt

@@ -0,0 +1,24 @@
+Analyze the following requirement or feature description and generate technical requirements for a Jira story:
+
+{{promptContent}}
+{{epicContext}}
+{{extraInstructions}}
+
+IMPORTANT:
+- Include technical considerations and implementation approach
+- Identify potential technical challenges
+- Suggest architecture patterns and best practices
+- Reference existing codebase patterns when relevant
+- Balance user value with technical feasibility
+
+Please analyze the requirement and provide it in the following JSON format with MARKDOWN formatting:
+
+{
+  "summary": "Brief, clear title for the story",
+  "description": "## Overview\n\n[High-level description of the feature/requirement]\n\n## User Story\n\nAs a [user type], I want [goal] so that [benefit]\n\n## Technical Considerations\n\n- Architecture patterns to use\n- Integration points\n- Data model changes\n- API design considerations\n- Performance implications\n\n## Implementation Approach\n\n1. Research existing patterns in codebase\n2. Design the solution\n3. Implement core functionality\n4. Add tests and documentation\n\n## Acceptance Criteria\n\n- [ ] Functional requirement 1\n- [ ] Functional requirement 2\n- [ ] Technical requirement (performance, security, etc.)\n- [ ] Tests are written and passing\n\n## Edge Cases & Considerations\n\n- Potential error scenarios\n- Backwards compatibility\n- Migration needs"
+}
+
+IMPORTANT:
+- Format the description using MARKDOWN (## headers, - bullets, **bold**, `code`, ``` code blocks)
+- This ensures proper rich formatting in Jira
+- Return ONLY valid JSON, no additional text