@shepai/cli 1.14.2 → 1.15.0

package/dist/src/infrastructure/services/agents/feature-agent/nodes/prompts/implement.prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"implement.prompt.d.ts","sourceRoot":"","sources":["../../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/prompts/implement.prompt.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,wBAAgB,2BAA2B,IAAI,MAAM,CAEpD"}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/prompts/implement.prompt.js

@@ -0,0 +1,18 @@
+/**
+ * Implement Phase Prompt — PLACEHOLDER
+ *
+ * The implement phase is not yet wired up. This returns a programming joke
+ * to clearly signal it's a placeholder while keeping the graph pipeline intact.
+ */
+const JOKES = [
+    'Why do programmers prefer dark mode? Because light attracts bugs.',
+    'A SQL query walks into a bar, walks up to two tables and asks... "Can I JOIN you?"',
+    "There are only 10 types of people: those who understand binary, and those who don't.",
+    "Why was the JavaScript developer sad? Because he didn't Node how to Express himself.",
+    "What's a programmer's favorite hangout place? Foo Bar.",
+    'To understand recursion, you must first understand recursion.',
+    "!false — it's funny because it's true.",
+];
+export function getImplementPlaceholderJoke() {
+    return JOKES[Math.floor(Math.random() * JOKES.length)];
+}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/prompts/plan.prompt.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Plan Phase Prompt
+ *
+ * Instructs the agent to create an implementation plan (plan.yaml) and
+ * a task breakdown (tasks.yaml) from the spec and research.
+ * The plan covers architecture decisions and rationale.
+ * The tasks cover concrete TDD work items.
+ */
+import type { FeatureAgentState } from '../../state.js';
+export declare function buildPlanPrompt(state: FeatureAgentState): string;
+//# sourceMappingURL=plan.prompt.d.ts.map

package/dist/src/infrastructure/services/agents/feature-agent/nodes/prompts/plan.prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.prompt.d.ts","sourceRoot":"","sources":["../../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/prompts/plan.prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,wBAAgB,eAAe,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAiKhE"}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/prompts/plan.prompt.js

@@ -0,0 +1,170 @@
+/**
+ * Plan Phase Prompt
+ *
+ * Instructs the agent to create an implementation plan (plan.yaml) and
+ * a task breakdown (tasks.yaml) from the spec and research.
+ * The plan covers architecture decisions and rationale.
+ * The tasks cover concrete TDD work items.
+ */
+import { readSpecFile } from '../node-helpers.js';
+export function buildPlanPrompt(state) {
+    const specContent = readSpecFile(state.specDir, 'spec.yaml');
+    const researchContent = readSpecFile(state.specDir, 'research.yaml');
+    return `You are a software architect performing the PLANNING phase of feature development.
+
+## Your Task
+
+1. Read the feature spec (with requirements) and research findings
+2. Create a high-level implementation plan with architecture decisions, phases, and rationale
+3. Break the work into ordered tasks with TDD cycles (RED-GREEN-REFACTOR)
+4. Write the plan to plan.yaml AND the task breakdown to tasks.yaml
+5. plan.yaml covers strategy and architecture — tasks.yaml covers the concrete work items (no duplication)
+
+## Feature Spec
+
+${specContent}
+
+## Research Findings
+
+${researchContent}
+
+## What to Produce
+
+### Implementation Plan (plan.yaml) — Strategy & Architecture Only
+- Architecture overview and how the feature fits the existing codebase
+- Key design decisions with rationale (reference research where applicable)
+- Implementation phases — high-level names and descriptions (NO individual task lists)
+- Files to create and files to modify
+- Risk mitigation strategies
+- Do NOT include task breakdowns — those belong exclusively in tasks.yaml
+
+### Task Breakdown (tasks.yaml)
+- Concrete, ordered tasks that implement the plan
+- Each task with TDD cycle: what test to write first (RED), minimal implementation (GREEN), cleanup (REFACTOR)
+- Dependencies between tasks
+- Acceptance criteria for each task
+- Effort estimates
+
+## Output Instructions
+
+You MUST write TWO files:
+
+### File 1: ${state.specDir}/plan.yaml
+
+  name: (feature name)
+  summary: >
+    (Summary of the implementation approach and key decisions)
+
+  relatedFeatures: []
+  technologies:
+    - (technologies needed)
+  relatedLinks: []
+
+  phases:
+    - id: phase-1
+      name: '(Phase Name — e.g., "Foundation & Domain Setup")'
+      description: '(What this phase accomplishes and why it comes first)'
+      parallel: false
+    - id: phase-2
+      name: '(Next Phase)'
+      description: '(What this phase accomplishes)'
+      parallel: false
+
+  filesToCreate:
+    - (path/to/new/file.ts)
+
+  filesToModify:
+    - (path/to/existing/file.ts)
+
+  openQuestions: []
+
+  content: |
+    ## Architecture Overview
+
+    (How the implementation fits the existing architecture.
+    Reference specific patterns from the codebase.)
+
+    ## Key Design Decisions
+
+    (For each decision, explain what was chosen, what alternatives were considered,
+    and why this approach is best. Reference research findings.)
+
+    ## Implementation Strategy
+
+    (High-level approach: phase ordering rationale, what comes first and why)
+
+    ## Risk Mitigation
+
+    | Risk | Mitigation |
+    | ---- | ---------- |
+    | (risk) | (how to handle it) |
+
+### File 2: ${state.specDir}/tasks.yaml
+
+  name: (feature name)
+  summary: >
+    (Summary: N tasks across M phases)
+
+  relatedFeatures: []
+  technologies: []
+  relatedLinks: []
+
+  tasks:
+    - id: task-1
+      phaseId: phase-1
+      title: '(Task Title)'
+      description: '(What this task accomplishes and why)'
+      state: Todo
+      dependencies: []
+      acceptanceCriteria:
+        - '(Specific, testable criterion)'
+        - '(Another criterion)'
+      tdd:
+        red:
+          - '(Write test that asserts X behavior)'
+        green:
+          - '(Implement minimal code to pass the test)'
+        refactor:
+          - '(Clean up: extract helpers, improve naming, etc.)'
+      estimatedEffort: '(time estimate, e.g., 1h, 30min)'
+
+    - id: task-2
+      phaseId: phase-1
+      title: '(Next Task)'
+      description: '...'
+      state: Todo
+      dependencies:
+        - task-1
+      acceptanceCriteria:
+        - '...'
+      tdd:
+        red:
+          - '...'
+        green:
+          - '...'
+        refactor:
+          - '...'
+      estimatedEffort: '...'
+
+  totalEstimate: '(total estimated hours)'
+  openQuestions: []
+
+  content: |
+    ## Summary
+
+    (Brief narrative: what gets built, in what order, and why.
+    Do NOT list individual tasks — the structured tasks array above is the source of truth.
+    Instead, summarize the overall flow: "First we set up X, then wire Y, finally integrate Z.")
+
+## Constraints
+
+- Write to BOTH ${state.specDir}/plan.yaml AND ${state.specDir}/tasks.yaml
+- Every code task MUST have TDD cycles (red/green/refactor) — non-code tasks (installs, docs) can set tdd: null
+- Tasks must be ordered by dependency — no task should depend on a later task
+- Each phase should group logically related tasks
+- Prefer small, focused tasks over large monolithic ones
+- Follow existing codebase conventions for file placement and naming
+- Do NOT create any other files
+- Do NOT modify any source code
+- Do NOT start implementing — planning only`;
+}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/prompts/requirements.prompt.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Requirements Phase Prompt
+ *
+ * Instructs the agent to build comprehensive requirements from the analysis,
+ * including product questions with AI-recommended default answers.
+ * Writes back to spec.yaml with full requirements.
+ */
+import type { FeatureAgentState } from '../../state.js';
+export declare function buildRequirementsPrompt(state: FeatureAgentState): string;
+//# sourceMappingURL=requirements.prompt.d.ts.map

package/dist/src/infrastructure/services/agents/feature-agent/nodes/prompts/requirements.prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirements.prompt.d.ts","sourceRoot":"","sources":["../../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/prompts/requirements.prompt.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CA4GxE"}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/prompts/requirements.prompt.js

@@ -0,0 +1,116 @@
+/**
+ * Requirements Phase Prompt
+ *
+ * Instructs the agent to build comprehensive requirements from the analysis,
+ * including product questions with AI-recommended default answers.
+ * Writes back to spec.yaml with full requirements.
+ */
+import { readSpecFile } from '../node-helpers.js';
+export function buildRequirementsPrompt(state) {
+    const specContent = readSpecFile(state.specDir, 'spec.yaml');
+    return `You are a product analyst performing the REQUIREMENTS phase of feature development.
+
+## Your Task
+
+1. Read the current spec with codebase analysis below
+2. Build a complete set of functional and non-functional requirements
+3. Define clear, measurable success criteria
+4. Identify product decisions that need input — for EACH one, provide your AI-recommended default answer with rationale
+5. Update the spec YAML file with the full requirements
+
+## Current Spec (with analysis)
+
+${specContent}
+
+## What to Produce
+
+### Requirements
+- **Functional requirements (FR-N)**: what the system must DO
+- **Non-functional requirements (NFR-N)**: performance, security, UX, maintainability constraints
+- **Success criteria**: measurable checkboxes that define "done"
+
+### Product Questions with AI Defaults
+For every ambiguous product decision, create an openQuestion entry with:
+- A clear question
+- resolved: true (your recommendation is the default)
+- Your recommended answer with reasoning
+
+The user can later review and override these defaults. This is the AI-recommended path — not the only option.
+
+## Output Instructions
+
+Update the file at: ${state.specDir}/spec.yaml
+
+Write the COMPLETE file. Preserve name/number/branch/technologies from analysis and update:
+
+  name: (keep)
+  number: (keep)
+  branch: (keep)
+  oneLiner: (keep or refine)
+  summary: >
+    (keep or refine based on requirements)
+  phase: Requirements
+  sizeEstimate: (keep or update if scope changed)
+
+  relatedFeatures: (keep)
+
+  technologies:
+    - (keep from analysis, add any new ones identified)
+
+  relatedLinks: (keep)
+
+  openQuestions:
+    - question: 'Should X use approach A or B?'
+      resolved: true
+      answer: 'Recommend A because [rationale]. Alternative: B if [condition].'
+    - question: 'What level of Y is needed?'
+      resolved: true
+      answer: 'Recommend Z level because [rationale].'
+
+  content: |
+    ## Problem Statement
+
+    (refined from analysis)
+
+    ## Success Criteria
+
+    - [ ] (measurable criterion 1)
+    - [ ] (measurable criterion 2)
+    - [ ] (etc.)
+
+    ## Functional Requirements
+
+    - **FR-1**: (requirement description)
+    - **FR-2**: (requirement description)
+
+    ## Non-Functional Requirements
+
+    - **NFR-1**: (performance/security/UX requirement)
+    - **NFR-2**: (etc.)
+
+    ## Product Questions & AI Recommendations
+
+    | # | Question | AI Recommendation | Rationale |
+    | - | -------- | ----------------- | --------- |
+    | 1 | (question) | (recommended answer) | (why) |
+
+    ## Affected Areas
+
+    (keep from analysis)
+
+    ## Dependencies
+
+    (keep from analysis, add any new ones)
+
+    ## Size Estimate
+
+    (keep or update with requirements-informed reasoning)
+
+## Constraints
+
+- Write ONLY to ${state.specDir}/spec.yaml
+- Every open question MUST have an AI-recommended default answer (resolved: true)
+- Requirements must be specific and testable, not vague
+- Do NOT create any other files
+- Do NOT modify any source code`;
+}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/prompts/research.prompt.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Research Phase Prompt
+ *
+ * Instructs the agent to research technical implementation details,
+ * evaluate libraries, and document architecture decisions with rationale.
+ * Writes to research.yaml.
+ */
+import type { FeatureAgentState } from '../../state.js';
+export declare function buildResearchPrompt(state: FeatureAgentState): string;
+//# sourceMappingURL=research.prompt.d.ts.map

package/dist/src/infrastructure/services/agents/feature-agent/nodes/prompts/research.prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"research.prompt.d.ts","sourceRoot":"","sources":["../../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/prompts/research.prompt.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAiHpE"}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/prompts/research.prompt.js

@@ -0,0 +1,121 @@
+/**
+ * Research Phase Prompt
+ *
+ * Instructs the agent to research technical implementation details,
+ * evaluate libraries, and document architecture decisions with rationale.
+ * Writes to research.yaml.
+ */
+import { readSpecFile } from '../node-helpers.js';
+export function buildResearchPrompt(state) {
+    const specContent = readSpecFile(state.specDir, 'spec.yaml');
+    const existingResearch = readSpecFile(state.specDir, 'research.yaml');
+    return `You are a technical architect performing the RESEARCH phase of feature development.
+
+## Your Task
+
+1. Read the feature spec with requirements below
+2. Research how to implement this feature technically
+3. For each technical decision, evaluate multiple options and choose one with clear rationale
+4. Evaluate libraries needed — document what to use, what to reject, and why
+5. Identify security and performance implications
+6. Write your complete research to the research YAML file
+
+## Feature Spec (with requirements)
+
+${specContent}
+
+${existingResearch ? `## Existing Research (update/expand this)\n\n${existingResearch}` : ''}
+
+## What to Research
+
+- **Architecture decisions**: how this fits into the existing codebase architecture
+- **Technology choices**: which libraries/tools/patterns to use (and which to reject)
+- **Data model changes**: any schema or model updates needed
+- **API design**: endpoints, contracts, interfaces
+- **Security implications**: authentication, authorization, data safety
+- **Performance considerations**: caching, optimization, scalability
+- **Integration points**: how this connects to existing systems
+
+## Output Instructions
+
+Write your research to: ${state.specDir}/research.yaml
+
+Use this YAML structure:
+
+  name: (feature name from spec)
+  summary: >
+    (2-3 sentence summary of research findings and key decisions)
+
+  relatedFeatures: []
+
+  technologies:
+    - (list all technologies evaluated or needed)
+
+  relatedLinks:
+    - (relevant documentation URLs discovered during research)
+
+  decisions:
+    - title: '(Decision Title — e.g., "Database Schema Design")'
+      chosen: '(The chosen approach)'
+      rejected:
+        - '(Alternative 1 that was considered and why not)'
+        - '(Alternative 2 that was considered and why not)'
+      rationale: >
+        (Detailed reasoning for why the chosen approach is best.
+        Reference the codebase's existing patterns where relevant.)
+
+    - title: '(Next Decision)'
+      chosen: '...'
+      rejected:
+        - '...'
+      rationale: >
+        ...
+
+  openQuestions:
+    - question: '(Any technical question that arose)'
+      resolved: true
+      answer: '(Resolution with technical reasoning)'
+
+  content: |
+    ## Technology Decisions
+
+    ### 1. (Decision Title)
+
+    **Chosen:** (approach)
+
+    **Rejected:**
+    - (alternative 1) — (why rejected)
+    - (alternative 2) — (why rejected)
+
+    **Rationale:** (detailed reasoning)
+
+    ### 2. (Next Decision)
+    ...
+
+    ## Library Analysis
+
+    | Library | Purpose | Decision | Reasoning |
+    | ------- | ------- | -------- | --------- |
+    | (lib)   | (purpose) | Use/Reject | (why) |
+
+    ## Security Considerations
+
+    (security implications and mitigations)
+
+    ## Performance Implications
+
+    (performance considerations and optimizations)
+
+    ## Architecture Notes
+
+    (how this fits into the existing codebase architecture)
+
+## Constraints
+
+- Write ONLY to ${state.specDir}/research.yaml
+- Every decision MUST have at least one rejected alternative with reasoning
+- Every decision MUST have clear rationale referencing the codebase where applicable
+- Prefer solutions that follow existing codebase patterns and conventions
+- Do NOT create any other files
+- Do NOT modify any source code`;
+}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/requirements.node.d.ts

@@ -0,0 +1,7 @@
+import type { IAgentExecutor } from '../../../../../application/ports/output/agent-executor.interface.js';
+/**
+ * Creates the requirements node that builds comprehensive requirements
+ * with product questions and AI-recommended defaults, writing to spec.yaml.
+ */
+export declare function createRequirementsNode(executor: IAgentExecutor): (state: import("../state.js").FeatureAgentState) => Promise<Partial<import("../state.js").FeatureAgentState>>;
+//# sourceMappingURL=requirements.node.d.ts.map

package/dist/src/infrastructure/services/agents/feature-agent/nodes/requirements.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirements.node.d.ts","sourceRoot":"","sources":["../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/requirements.node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wDAAwD,CAAC;AAI7F;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,cAAc,iHAE9D"}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/requirements.node.js

@@ -0,0 +1,9 @@
+import { executeNode } from './node-helpers.js';
+import { buildRequirementsPrompt } from './prompts/requirements.prompt.js';
+/**
+ * Creates the requirements node that builds comprehensive requirements
+ * with product questions and AI-recommended defaults, writing to spec.yaml.
+ */
+export function createRequirementsNode(executor) {
+    return executeNode('requirements', executor, buildRequirementsPrompt);
+}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/research.node.d.ts

@@ -0,0 +1,7 @@
+import type { IAgentExecutor } from '../../../../../application/ports/output/agent-executor.interface.js';
+/**
+ * Creates the research node that evaluates technical approaches,
+ * libraries, and architecture decisions, writing to research.yaml.
+ */
+export declare function createResearchNode(executor: IAgentExecutor): (state: import("../state.js").FeatureAgentState) => Promise<Partial<import("../state.js").FeatureAgentState>>;
+//# sourceMappingURL=research.node.d.ts.map

package/dist/src/infrastructure/services/agents/feature-agent/nodes/research.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"research.node.d.ts","sourceRoot":"","sources":["../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/research.node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wDAAwD,CAAC;AAI7F;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,iHAE1D"}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/research.node.js

@@ -0,0 +1,9 @@
+import { executeNode } from './node-helpers.js';
+import { buildResearchPrompt } from './prompts/research.prompt.js';
+/**
+ * Creates the research node that evaluates technical approaches,
+ * libraries, and architecture decisions, writing to research.yaml.
+ */
+export function createResearchNode(executor) {
+    return executeNode('research', executor, buildResearchPrompt);
+}

package/dist/src/infrastructure/services/agents/feature-agent/state.d.ts

@@ -0,0 +1,39 @@
+/**
+ * State annotation for the feature-agent graph.
+ *
+ * Uses LangGraph's Annotation API to define state channels.
+ * The `messages` channel uses a reducer to accumulate messages
+ * from all nodes as the graph executes.
+ */
+export declare const FeatureAgentAnnotation: import("@langchain/langgraph").AnnotationRoot<{
+    featureId: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    repositoryPath: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    specDir: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    worktreePath: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    currentNode: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    approvalMode: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+}>;
+export type FeatureAgentState = typeof FeatureAgentAnnotation.State;
+//# sourceMappingURL=state.d.ts.map

package/dist/src/infrastructure/services/agents/feature-agent/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/feature-agent/state.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBjC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,OAAO,sBAAsB,CAAC,KAAK,CAAC"}

package/dist/src/infrastructure/services/agents/feature-agent/state.js

@@ -0,0 +1,27 @@
+import { Annotation } from '@langchain/langgraph';
+/**
+ * State annotation for the feature-agent graph.
+ *
+ * Uses LangGraph's Annotation API to define state channels.
+ * The `messages` channel uses a reducer to accumulate messages
+ * from all nodes as the graph executes.
+ */
+export const FeatureAgentAnnotation = Annotation.Root({
+    featureId: (Annotation),
+    repositoryPath: (Annotation),
+    specDir: (Annotation),
+    worktreePath: (Annotation),
+    currentNode: (Annotation),
+    error: Annotation({
+        reducer: (prev, next) => (next !== undefined ? next : prev),
+        default: () => null,
+    }),
+    approvalMode: Annotation({
+        reducer: (prev, next) => next ?? prev,
+        default: () => undefined,
+    }),
+    messages: Annotation({
+        reducer: (prev, next) => [...prev, ...next],
+        default: () => [],
+    }),
+});

package/dist/src/infrastructure/services/external/github-issue.service.d.ts

@@ -0,0 +1,19 @@
+/**
+ * GitHub Issue Fetcher Service
+ *
+ * Fetches GitHub issues using the gh CLI subprocess.
+ * Supports owner/repo#number and #number (current repo) formats.
+ */
+import type { IExternalIssueFetcher, ExternalIssue } from '../../../application/ports/output/external-issue-fetcher.interface.js';
+type ExecFileFn = (cmd: string, args: string[], options?: object) => Promise<{
+    stdout: string;
+    stderr?: string;
+}>;
+export declare class GitHubIssueFetcher implements Pick<IExternalIssueFetcher, 'fetchGitHubIssue'> {
+    private readonly execFile;
+    constructor(execFile: ExecFileFn);
+    fetchGitHubIssue(ref: string): Promise<ExternalIssue>;
+    private parseRef;
+}
+export {};
+//# sourceMappingURL=github-issue.service.d.ts.map

package/dist/src/infrastructure/services/external/github-issue.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-issue.service.d.ts","sourceRoot":"","sources":["../../../../../src/infrastructure/services/external/github-issue.service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,qBAAqB,EACrB,aAAa,EACd,MAAM,gEAAgE,CAAC;AAMxE,KAAK,UAAU,GAAG,CAChB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAElD,qBAAa,kBAAmB,YAAW,IAAI,CAAC,qBAAqB,EAAE,kBAAkB,CAAC;IAC5E,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,UAAU;IAE3C,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAyC3D,OAAO,CAAC,QAAQ;CAoBjB"}