@shepai/cli 1.14.1 → 1.15.0

package/dist/src/application/use-cases/agents/stop-agent-run.use-case.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Stop Agent Run Use Case
+ *
+ * Sends SIGTERM to a running agent's worker process and marks it as cancelled.
+ */
+import type { IAgentRunRepository } from '../../ports/output/agent-run-repository.interface.js';
+export declare class StopAgentRunUseCase {
+    private readonly agentRunRepository;
+    constructor(agentRunRepository: IAgentRunRepository);
+    execute(id: string): Promise<{
+        stopped: boolean;
+        reason: string;
+    }>;
+}
+//# sourceMappingURL=stop-agent-run.use-case.d.ts.map

package/dist/src/application/use-cases/agents/stop-agent-run.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop-agent-run.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/agents/stop-agent-run.use-case.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sDAAsD,CAAC;AAGhG,qBACa,mBAAmB;IAG5B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,mBAAmB;IAGpD,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CA4DzE"}

package/dist/src/application/use-cases/agents/stop-agent-run.use-case.js

@@ -0,0 +1,86 @@
+/**
+ * Stop Agent Run Use Case
+ *
+ * Sends SIGTERM to a running agent's worker process and marks it as cancelled.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+import { AgentRunStatus } from '../../../domain/generated/output.js';
+let StopAgentRunUseCase = class StopAgentRunUseCase {
+    agentRunRepository;
+    constructor(agentRunRepository) {
+        this.agentRunRepository = agentRunRepository;
+    }
+    async execute(id) {
+        const run = await this.agentRunRepository.findById(id);
+        if (!run) {
+            return { stopped: false, reason: 'Agent run not found' };
+        }
+        const terminalStatuses = new Set([
+            AgentRunStatus.completed,
+            AgentRunStatus.failed,
+            AgentRunStatus.interrupted,
+            AgentRunStatus.cancelled,
+        ]);
+        if (terminalStatuses.has(run.status)) {
+            return { stopped: false, reason: `Agent run already in terminal state: ${run.status}` };
+        }
+        if (!run.pid) {
+            // No PID — just mark as cancelled
+            const now = new Date();
+            await this.agentRunRepository.updateStatus(id, AgentRunStatus.cancelled, {
+                error: 'Cancelled by user (no PID)',
+                completedAt: now,
+                updatedAt: now,
+            });
+            return { stopped: true, reason: 'Marked as cancelled (no PID to signal)' };
+        }
+        // Check if process is alive
+        let alive = false;
+        try {
+            process.kill(run.pid, 0);
+            alive = true;
+        }
+        catch {
+            alive = false;
+        }
+        if (alive) {
+            // Send SIGTERM for graceful shutdown
+            try {
+                process.kill(run.pid, 'SIGTERM');
+            }
+            catch {
+                // Process may have died between check and signal
+            }
+        }
+        const now = new Date();
+        await this.agentRunRepository.updateStatus(id, AgentRunStatus.cancelled, {
+            error: 'Cancelled by user',
+            completedAt: now,
+            updatedAt: now,
+        });
+        return {
+            stopped: true,
+            reason: alive
+                ? `Sent SIGTERM to PID ${run.pid}`
+                : `Process already dead, marked as cancelled`,
+        };
+    }
+};
+StopAgentRunUseCase = __decorate([
+    injectable(),
+    __param(0, inject('IAgentRunRepository')),
+    __metadata("design:paramtypes", [Object])
+], StopAgentRunUseCase);
+export { StopAgentRunUseCase };

package/dist/src/application/use-cases/features/create-feature.use-case.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Create Feature Use Case
+ *
+ * Creates a new feature entity with a git worktree for isolated development,
+ * initializes the spec directory with YAML templates, then spawns the
+ * feature agent to begin autonomous SDLC processing.
+ *
+ * Business Rules:
+ * - AI generates slug/name/description from user's free-text input
+ * - Falls back to regex-based slug if AI fails
+ * - Full user input is preserved as-is in spec.yaml
+ * - Slug must be unique within the repository
+ * - A git worktree is created at ~/.shep/repos/HASH/wt/SLUG/
+ * - Spec YAML files are scaffolded at WORKTREE/specs/NNN-SLUG/
+ * - Feature agent is spawned with the spec dir path
+ * - specPath is persisted on the Feature record
+ * - Initial lifecycle is Requirements
+ */
+import type { Feature } from '../../../domain/generated/output.js';
+import type { IFeatureRepository } from '../../ports/output/feature-repository.interface.js';
+import type { IWorktreeService } from '../../ports/output/worktree-service.interface.js';
+import type { IFeatureAgentProcessService } from '../../ports/output/feature-agent-process.interface.js';
+import type { IAgentRunRepository } from '../../ports/output/agent-run-repository.interface.js';
+import type { ISpecInitializerService } from '../../ports/output/spec-initializer.interface.js';
+import type { IAgentExecutorFactory } from '../../ports/output/agent-executor-factory.interface.js';
+export interface CreateFeatureInput {
+    userInput: string;
+    repositoryPath: string;
+    approvalMode?: string;
+}
+export declare class CreateFeatureUseCase {
+    private readonly featureRepo;
+    private readonly worktreeService;
+    private readonly agentProcess;
+    private readonly runRepository;
+    private readonly specInitializer;
+    private readonly executorFactory;
+    constructor(featureRepo: IFeatureRepository, worktreeService: IWorktreeService, agentProcess: IFeatureAgentProcessService, runRepository: IAgentRunRepository, specInitializer: ISpecInitializerService, executorFactory: IAgentExecutorFactory);
+    execute(input: CreateFeatureInput): Promise<Feature>;
+    private generateMetadata;
+    private toSlug;
+}
+//# sourceMappingURL=create-feature.use-case.d.ts.map

package/dist/src/application/use-cases/features/create-feature.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-feature.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/features/create-feature.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qCAAqC,CAAC;AAEnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oDAAoD,CAAC;AAC7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kDAAkD,CAAC;AACzF,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,uDAAuD,CAAC;AACzG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sDAAsD,CAAC;AAChG,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAC;AAChG,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wDAAwD,CAAC;AAOpG,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAQD,qBACa,oBAAoB;IAG7B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAE5B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAEhC,OAAO,CAAC,QAAQ,CAAC,YAAY;IAE7B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAE9B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAEhC,OAAO,CAAC,QAAQ,CAAC,eAAe;gBAVf,WAAW,EAAE,kBAAkB,EAE/B,eAAe,EAAE,gBAAgB,EAEjC,YAAY,EAAE,2BAA2B,EAEzC,aAAa,EAAE,mBAAmB,EAElC,eAAe,EAAE,uBAAuB,EAExC,eAAe,EAAE,qBAAqB;IAGnD,OAAO,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;YA8E5C,gBAAgB;IA6C9B,OAAO,CAAC,MAAM;CAQf"}

package/dist/src/application/use-cases/features/create-feature.use-case.js

@@ -0,0 +1,166 @@
+/**
+ * Create Feature Use Case
+ *
+ * Creates a new feature entity with a git worktree for isolated development,
+ * initializes the spec directory with YAML templates, then spawns the
+ * feature agent to begin autonomous SDLC processing.
+ *
+ * Business Rules:
+ * - AI generates slug/name/description from user's free-text input
+ * - Falls back to regex-based slug if AI fails
+ * - Full user input is preserved as-is in spec.yaml
+ * - Slug must be unique within the repository
+ * - A git worktree is created at ~/.shep/repos/HASH/wt/SLUG/
+ * - Spec YAML files are scaffolded at WORKTREE/specs/NNN-SLUG/
+ * - Feature agent is spawned with the spec dir path
+ * - specPath is persisted on the Feature record
+ * - Initial lifecycle is Requirements
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+import { randomUUID } from 'node:crypto';
+import { SdlcLifecycle } from '../../../domain/generated/output.js';
+import { AgentRunStatus } from '../../../domain/generated/output.js';
+import { getSettings } from '../../../infrastructure/services/settings.service.js';
+/** Maximum characters of user input sent to the AI for metadata generation. */
+const MAX_INPUT_FOR_AI = 500;
+let CreateFeatureUseCase = class CreateFeatureUseCase {
+    featureRepo;
+    worktreeService;
+    agentProcess;
+    runRepository;
+    specInitializer;
+    executorFactory;
+    constructor(featureRepo, worktreeService, agentProcess, runRepository, specInitializer, executorFactory) {
+        this.featureRepo = featureRepo;
+        this.worktreeService = worktreeService;
+        this.agentProcess = agentProcess;
+        this.runRepository = runRepository;
+        this.specInitializer = specInitializer;
+        this.executorFactory = executorFactory;
+    }
+    async execute(input) {
+        const metadata = await this.generateMetadata(input.userInput);
+        const slug = metadata.slug;
+        const branch = `feat/${slug}`;
+        const existing = await this.featureRepo.findBySlug(slug, input.repositoryPath);
+        if (existing) {
+            throw new Error(`Feature with slug "${slug}" already exists in this repository`);
+        }
+        // Determine next feature number for this repo
+        const existingFeatures = await this.featureRepo.list({
+            repositoryPath: input.repositoryPath,
+        });
+        const featureNumber = existingFeatures.length + 1;
+        const now = new Date();
+        const runId = randomUUID();
+        // Create git worktree for isolated development
+        const worktreePath = this.worktreeService.getWorktreePath(input.repositoryPath, branch);
+        await this.worktreeService.create(input.repositoryPath, branch, worktreePath);
+        // Initialize spec directory — full user input goes into spec.yaml as-is
+        const { specDir } = await this.specInitializer.initialize(worktreePath, slug, featureNumber, input.userInput);
+        const feature = {
+            id: randomUUID(),
+            name: metadata.name,
+            slug,
+            description: metadata.description,
+            repositoryPath: input.repositoryPath,
+            branch,
+            lifecycle: SdlcLifecycle.Requirements,
+            messages: [],
+            relatedArtifacts: [],
+            agentRunId: runId,
+            specPath: specDir,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.featureRepo.create(feature);
+        // Create agent run record and spawn background worker
+        const settings = getSettings();
+        const agentRun = {
+            id: runId,
+            agentType: settings.agent.type,
+            agentName: 'feature-agent',
+            status: AgentRunStatus.pending,
+            prompt: input.userInput,
+            threadId: randomUUID(),
+            featureId: feature.id,
+            repositoryPath: input.repositoryPath,
+            ...(input.approvalMode ? { approvalMode: input.approvalMode } : {}),
+            createdAt: now.toISOString(),
+            updatedAt: now.toISOString(),
+        };
+        await this.runRepository.create(agentRun);
+        this.agentProcess.spawn(feature.id, runId, input.repositoryPath, specDir, worktreePath, input.approvalMode ? { approvalMode: input.approvalMode } : undefined);
+        return feature;
+    }
+    async generateMetadata(userInput) {
+        try {
+            const settings = getSettings();
+            const executor = this.executorFactory.createExecutor(settings.agent.type, settings.agent);
+            const truncated = userInput.length > MAX_INPUT_FOR_AI
+                ? `${userInput.slice(0, MAX_INPUT_FOR_AI)}...`
+                : userInput;
+            const prompt = `Generate feature metadata from this user request:
+"${truncated}"
+
+Return ONLY a JSON object with these fields:
+- slug: kebab-case identifier, 2-4 words max (e.g., "github-oauth-login")
+- name: short human-readable title (e.g., "GitHub OAuth Login")
+- description: refined 1-2 sentence description
+
+JSON only, no markdown fences.`;
+            const result = await executor.execute(prompt, {
+                maxTurns: 1,
+                allowedTools: [],
+            });
+            const parsed = JSON.parse(result.result);
+            if (!parsed.slug || !parsed.name || !parsed.description) {
+                throw new Error('Missing required fields in AI response');
+            }
+            return {
+                slug: this.toSlug(parsed.slug),
+                name: parsed.name,
+                description: parsed.description,
+            };
+        }
+        catch {
+            // Fallback to regex-based slug generation
+            return {
+                slug: this.toSlug(userInput),
+                name: userInput,
+                description: userInput,
+            };
+        }
+    }
+    toSlug(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^a-z0-9\s-]/g, '')
+            .replace(/\s+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+    }
+};
+CreateFeatureUseCase = __decorate([
+    injectable(),
+    __param(0, inject('IFeatureRepository')),
+    __param(1, inject('IWorktreeService')),
+    __param(2, inject('IFeatureAgentProcessService')),
+    __param(3, inject('IAgentRunRepository')),
+    __param(4, inject('ISpecInitializerService')),
+    __param(5, inject('IAgentExecutorFactory')),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, Object, Object])
+], CreateFeatureUseCase);
+export { CreateFeatureUseCase };

package/dist/src/application/use-cases/features/delete-feature.use-case.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Delete Feature Use Case
+ *
+ * Orchestrates feature deletion including:
+ * - Cancelling any running/pending agent runs
+ * - Removing the git worktree
+ * - Deleting the feature record
+ *
+ * Business Rules:
+ * - Throws if the feature does not exist
+ * - Cancels running/pending agent runs before deletion
+ * - Gracefully handles worktree removal failures
+ */
+import type { Feature } from '../../../domain/generated/output.js';
+import type { IFeatureRepository } from '../../ports/output/feature-repository.interface.js';
+import type { IWorktreeService } from '../../ports/output/worktree-service.interface.js';
+import type { IFeatureAgentProcessService } from '../../ports/output/feature-agent-process.interface.js';
+import type { IAgentRunRepository } from '../../ports/output/agent-run-repository.interface.js';
+export declare class DeleteFeatureUseCase {
+    private readonly featureRepo;
+    private readonly worktreeService;
+    private readonly processService;
+    private readonly runRepo;
+    constructor(featureRepo: IFeatureRepository, worktreeService: IWorktreeService, processService: IFeatureAgentProcessService, runRepo: IAgentRunRepository);
+    execute(featureId: string): Promise<Feature>;
+}
+//# sourceMappingURL=delete-feature.use-case.d.ts.map

package/dist/src/application/use-cases/features/delete-feature.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-feature.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/features/delete-feature.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qCAAqC,CAAC;AAEnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oDAAoD,CAAC;AAC7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kDAAkD,CAAC;AACzF,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,uDAAuD,CAAC;AACzG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sDAAsD,CAAC;AAEhG,qBACa,oBAAoB;IAEC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC9B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAE5D,OAAO,CAAC,QAAQ,CAAC,cAAc;IACA,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAJR,WAAW,EAAE,kBAAkB,EACjC,eAAe,EAAE,gBAAgB,EAE7D,cAAc,EAAE,2BAA2B,EACZ,OAAO,EAAE,mBAAmB;IAGxE,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAyCnD"}

package/dist/src/application/use-cases/features/delete-feature.use-case.js

@@ -0,0 +1,83 @@
+/**
+ * Delete Feature Use Case
+ *
+ * Orchestrates feature deletion including:
+ * - Cancelling any running/pending agent runs
+ * - Removing the git worktree
+ * - Deleting the feature record
+ *
+ * Business Rules:
+ * - Throws if the feature does not exist
+ * - Cancels running/pending agent runs before deletion
+ * - Gracefully handles worktree removal failures
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+import { AgentRunStatus } from '../../../domain/generated/output.js';
+let DeleteFeatureUseCase = class DeleteFeatureUseCase {
+    featureRepo;
+    worktreeService;
+    processService;
+    runRepo;
+    constructor(featureRepo, worktreeService, processService, runRepo) {
+        this.featureRepo = featureRepo;
+        this.worktreeService = worktreeService;
+        this.processService = processService;
+        this.runRepo = runRepo;
+    }
+    async execute(featureId) {
+        // 1. Find feature (exact or prefix match)
+        const feature = (await this.featureRepo.findById(featureId)) ??
+            (await this.featureRepo.findByIdPrefix(featureId));
+        if (!feature) {
+            throw new Error(`Feature not found: "${featureId}"`);
+        }
+        // 2. Cancel running/pending agent run if present
+        if (feature.agentRunId) {
+            const run = await this.runRepo.findById(feature.agentRunId);
+            if (run && (run.status === AgentRunStatus.running || run.status === AgentRunStatus.pending)) {
+                // Kill the OS process if still alive
+                if (run.pid && this.processService.isAlive(run.pid)) {
+                    try {
+                        process.kill(run.pid);
+                    }
+                    catch {
+                        // Process may have already exited
+                    }
+                }
+                await this.runRepo.updateStatus(run.id, AgentRunStatus.cancelled);
+            }
+        }
+        // 3. Remove worktree (ignore errors if already removed)
+        const worktreePath = this.worktreeService.getWorktreePath(feature.repositoryPath, feature.branch);
+        try {
+            await this.worktreeService.remove(worktreePath);
+        }
+        catch {
+            // Worktree might already be removed - that's fine
+        }
+        // 4. Delete feature record
+        await this.featureRepo.delete(feature.id);
+        return feature;
+    }
+};
+DeleteFeatureUseCase = __decorate([
+    injectable(),
+    __param(0, inject('IFeatureRepository')),
+    __param(1, inject('IWorktreeService')),
+    __param(2, inject('IFeatureAgentProcessService')),
+    __param(3, inject('IAgentRunRepository')),
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
+], DeleteFeatureUseCase);
+export { DeleteFeatureUseCase };

package/dist/src/application/use-cases/features/list-features.use-case.d.ts

@@ -0,0 +1,17 @@
+/**
+ * List Features Use Case
+ *
+ * Retrieves features with optional filtering by repository path or lifecycle.
+ *
+ * Business Rules:
+ * - Returns all features when no filters are provided
+ * - Filters are passed through to the repository
+ */
+import type { Feature } from '../../../domain/generated/output.js';
+import type { IFeatureRepository, FeatureListFilters } from '../../ports/output/feature-repository.interface.js';
+export declare class ListFeaturesUseCase {
+    private readonly featureRepo;
+    constructor(featureRepo: IFeatureRepository);
+    execute(filters?: FeatureListFilters): Promise<Feature[]>;
+}
+//# sourceMappingURL=list-features.use-case.d.ts.map

package/dist/src/application/use-cases/features/list-features.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-features.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/features/list-features.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qCAAqC,CAAC;AACnE,OAAO,KAAK,EACV,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,oDAAoD,CAAC;AAE5D,qBACa,mBAAmB;IAG5B,OAAO,CAAC,QAAQ,CAAC,WAAW;gBAAX,WAAW,EAAE,kBAAkB;IAG5C,OAAO,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;CAGhE"}

package/dist/src/application/use-cases/features/list-features.use-case.js

@@ -0,0 +1,37 @@
+/**
+ * List Features Use Case
+ *
+ * Retrieves features with optional filtering by repository path or lifecycle.
+ *
+ * Business Rules:
+ * - Returns all features when no filters are provided
+ * - Filters are passed through to the repository
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+let ListFeaturesUseCase = class ListFeaturesUseCase {
+    featureRepo;
+    constructor(featureRepo) {
+        this.featureRepo = featureRepo;
+    }
+    async execute(filters) {
+        return this.featureRepo.list(filters);
+    }
+};
+ListFeaturesUseCase = __decorate([
+    injectable(),
+    __param(0, inject('IFeatureRepository')),
+    __metadata("design:paramtypes", [Object])
+], ListFeaturesUseCase);
+export { ListFeaturesUseCase };

package/dist/src/application/use-cases/features/resume-feature.use-case.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Resume Feature Use Case
+ *
+ * Resumes an interrupted, failed, or waiting_approval feature agent run.
+ * Creates a new AgentRun record and spawns a worker with --resume flag.
+ */
+import type { Feature, AgentRun } from '../../../domain/generated/output.js';
+import type { IFeatureRepository } from '../../ports/output/feature-repository.interface.js';
+import type { IAgentRunRepository } from '../../ports/output/agent-run-repository.interface.js';
+import type { IFeatureAgentProcessService } from '../../ports/output/feature-agent-process.interface.js';
+import type { IWorktreeService } from '../../ports/output/worktree-service.interface.js';
+export interface ResumeFeatureResult {
+    feature: Feature;
+    newRun: AgentRun;
+}
+export declare class ResumeFeatureUseCase {
+    private readonly featureRepo;
+    private readonly runRepo;
+    private readonly processService;
+    private readonly worktreeService;
+    constructor(featureRepo: IFeatureRepository, runRepo: IAgentRunRepository, processService: IFeatureAgentProcessService, worktreeService: IWorktreeService);
+    execute(featureId: string): Promise<ResumeFeatureResult>;
+}
+//# sourceMappingURL=resume-feature.use-case.d.ts.map

package/dist/src/application/use-cases/features/resume-feature.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume-feature.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/features/resume-feature.use-case.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAE7E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oDAAoD,CAAC;AAC7F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sDAAsD,CAAC;AAChG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,uDAAuD,CAAC;AACzG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kDAAkD,CAAC;AAQzF,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,QAAQ,CAAC;CAClB;AAED,qBACa,oBAAoB;IAG7B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAE5B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAExB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,eAAe;gBANf,WAAW,EAAE,kBAAkB,EAE/B,OAAO,EAAE,mBAAmB,EAE5B,cAAc,EAAE,2BAA2B,EAE3C,eAAe,EAAE,gBAAgB;IAG9C,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAwE/D"}

package/dist/src/application/use-cases/features/resume-feature.use-case.js

@@ -0,0 +1,100 @@
+/**
+ * Resume Feature Use Case
+ *
+ * Resumes an interrupted, failed, or waiting_approval feature agent run.
+ * Creates a new AgentRun record and spawns a worker with --resume flag.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+import { randomUUID } from 'node:crypto';
+import { AgentRunStatus } from '../../../domain/generated/output.js';
+const RESUMABLE_STATUSES = new Set([
+    AgentRunStatus.interrupted,
+    AgentRunStatus.failed,
+    AgentRunStatus.waitingApproval,
+]);
+let ResumeFeatureUseCase = class ResumeFeatureUseCase {
+    featureRepo;
+    runRepo;
+    processService;
+    worktreeService;
+    constructor(featureRepo, runRepo, processService, worktreeService) {
+        this.featureRepo = featureRepo;
+        this.runRepo = runRepo;
+        this.processService = processService;
+        this.worktreeService = worktreeService;
+    }
+    async execute(featureId) {
+        // Resolve feature by exact ID or prefix
+        const feature = (await this.featureRepo.findById(featureId)) ??
+            (await this.featureRepo.findByIdPrefix(featureId));
+        if (!feature) {
+            throw new Error(`Feature not found: ${featureId}`);
+        }
+        // Load the most recent agent run
+        if (!feature.agentRunId) {
+            throw new Error(`No agent run found for feature "${feature.name}"`);
+        }
+        const lastRun = await this.runRepo.findById(feature.agentRunId);
+        if (!lastRun) {
+            throw new Error(`No agent run found for feature "${feature.name}"`);
+        }
+        // Validate the run is in a resumable state
+        if (lastRun.status === AgentRunStatus.running) {
+            throw new Error('Agent is still running — stop it first before resuming');
+        }
+        if (lastRun.status === AgentRunStatus.completed) {
+            throw new Error('Agent already completed successfully');
+        }
+        if (!RESUMABLE_STATUSES.has(lastRun.status)) {
+            throw new Error(`Agent run is not in a resumable state (status: ${lastRun.status})`);
+        }
+        // Create a new agent run record that continues the same thread
+        const now = new Date();
+        const newRunId = randomUUID();
+        const newRun = {
+            id: newRunId,
+            agentType: lastRun.agentType,
+            agentName: lastRun.agentName,
+            status: AgentRunStatus.pending,
+            prompt: lastRun.prompt,
+            threadId: lastRun.threadId, // Same thread for checkpoint continuity
+            featureId: feature.id,
+            repositoryPath: feature.repositoryPath,
+            approvalMode: lastRun.approvalMode,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.runRepo.create(newRun);
+        // Update feature to reference the new run
+        await this.featureRepo.update({
+            ...feature,
+            agentRunId: newRunId,
+            updatedAt: now,
+        });
+        // Derive worktree path and spawn resume worker
+        const worktreePath = this.worktreeService.getWorktreePath(feature.repositoryPath, feature.branch);
+        this.processService.spawn(feature.id, newRunId, feature.repositoryPath, worktreePath, worktreePath, { resume: true, approvalMode: lastRun.approvalMode });
+        return { feature, newRun };
+    }
+};
+ResumeFeatureUseCase = __decorate([
+    injectable(),
+    __param(0, inject('IFeatureRepository')),
+    __param(1, inject('IAgentRunRepository')),
+    __param(2, inject('IFeatureAgentProcessService')),
+    __param(3, inject('IWorktreeService')),
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
+], ResumeFeatureUseCase);
+export { ResumeFeatureUseCase };

package/dist/src/application/use-cases/features/show-feature.use-case.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Show Feature Use Case
+ *
+ * Retrieves a single feature by its ID.
+ *
+ * Business Rules:
+ * - Throws if the feature does not exist
+ * - Error message includes the requested ID for debugging
+ */
+import type { Feature } from '../../../domain/generated/output.js';
+import type { IFeatureRepository } from '../../ports/output/feature-repository.interface.js';
+export declare class ShowFeatureUseCase {
+    private readonly featureRepo;
+    constructor(featureRepo: IFeatureRepository);
+    execute(featureId: string): Promise<Feature>;
+}
+//# sourceMappingURL=show-feature.use-case.d.ts.map

package/dist/src/application/use-cases/features/show-feature.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"show-feature.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/features/show-feature.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qCAAqC,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oDAAoD,CAAC;AAE7F,qBACa,kBAAkB;IAG3B,OAAO,CAAC,QAAQ,CAAC,WAAW;gBAAX,WAAW,EAAE,kBAAkB;IAG5C,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAUnD"}