@shepai/cli 1.37.3 → 1.38.0

package/web/.next/standalone/src/presentation/web/.next/server/server-reference-manifest.json

@@ -1,5 +1,141 @@
 {
-  "node": {},
+  "node": {
+    "40b4d17bb315ea41b7dba3e31da95a288148dc6be2": {
+      "workers": {
+        "app/page": {
+          "moduleId": 80016,
+          "async": false,
+          "exportedName": "approveFeature",
+          "filename": "src/presentation/web/app/actions/approve-feature.ts"
+        }
+      },
+      "layer": {
+        "app/page": "action-browser"
+      },
+      "filename": "src/presentation/web/app/actions/approve-feature.ts",
+      "exportedName": "approveFeature"
+    },
+    "4025baaade2d7afa8754ad69f3e071931ae4ddbefb": {
+      "workers": {
+        "app/page": {
+          "moduleId": 80016,
+          "async": false,
+          "exportedName": "getFeatureArtifact",
+          "filename": "src/presentation/web/app/actions/get-feature-artifact.ts"
+        }
+      },
+      "layer": {
+        "app/page": "action-browser"
+      },
+      "filename": "src/presentation/web/app/actions/get-feature-artifact.ts",
+      "exportedName": "getFeatureArtifact"
+    },
+    "404d5def10982371ae47d4fc7243238a78d9afba46": {
+      "workers": {
+        "app/page": {
+          "moduleId": 80016,
+          "async": false,
+          "exportedName": "getResearchArtifact",
+          "filename": "src/presentation/web/app/actions/get-research-artifact.ts"
+        }
+      },
+      "layer": {
+        "app/page": "action-browser"
+      },
+      "filename": "src/presentation/web/app/actions/get-research-artifact.ts",
+      "exportedName": "getResearchArtifact"
+    },
+    "40af1c72c9243f14f972789f67b572e5832a0abad4": {
+      "workers": {
+        "app/page": {
+          "moduleId": 80016,
+          "async": false,
+          "exportedName": "openIde",
+          "filename": "src/presentation/web/app/actions/open-ide.ts"
+        }
+      },
+      "layer": {
+        "app/page": "action-browser"
+      },
+      "filename": "src/presentation/web/app/actions/open-ide.ts",
+      "exportedName": "openIde"
+    },
+    "405cabee8ccbbf834772f21e2aebb0c790513b0521": {
+      "workers": {
+        "app/page": {
+          "moduleId": 80016,
+          "async": false,
+          "exportedName": "openShell",
+          "filename": "src/presentation/web/app/actions/open-shell.ts"
+        }
+      },
+      "layer": {
+        "app/page": "action-browser"
+      },
+      "filename": "src/presentation/web/app/actions/open-shell.ts",
+      "exportedName": "openShell"
+    },
+    "40d5fe996f4d57feba1bf46646f44c49596a785bd3": {
+      "workers": {
+        "app/page": {
+          "moduleId": 80016,
+          "async": false,
+          "exportedName": "openFolder",
+          "filename": "src/presentation/web/app/actions/open-folder.ts"
+        }
+      },
+      "layer": {
+        "app/page": "action-browser"
+      },
+      "filename": "src/presentation/web/app/actions/open-folder.ts",
+      "exportedName": "openFolder"
+    },
+    "00d2b83b560c0bfd49830ef3bf814069889fbc1e11": {
+      "workers": {
+        "app/page": {
+          "moduleId": 80016,
+          "async": false,
+          "exportedName": "pickFolder",
+          "filename": "src/presentation/web/app/actions/pick-folder.ts"
+        }
+      },
+      "layer": {
+        "app/page": "action-browser"
+      },
+      "filename": "src/presentation/web/app/actions/pick-folder.ts",
+      "exportedName": "pickFolder"
+    },
+    "4064958f2757d076210e3cb537fce46c0f9aede8ee": {
+      "workers": {
+        "app/page": {
+          "moduleId": 80016,
+          "async": false,
+          "exportedName": "createFeature",
+          "filename": "src/presentation/web/app/actions/create-feature.ts"
+        }
+      },
+      "layer": {
+        "app/page": "action-browser"
+      },
+      "filename": "src/presentation/web/app/actions/create-feature.ts",
+      "exportedName": "createFeature"
+    },
+    "40c2d629475e8317b7853c1acf8fce629f0afad154": {
+      "workers": {
+        "app/page": {
+          "moduleId": 80016,
+          "async": false,
+          "exportedName": "deleteFeature",
+          "filename": "src/presentation/web/app/actions/delete-feature.ts"
+        }
+      },
+      "layer": {
+        "app/page": "action-browser"
+      },
+      "filename": "src/presentation/web/app/actions/delete-feature.ts",
+      "exportedName": "deleteFeature"
+    }
+  },
   "edge": {},
-  "encryptionKey": "ZbWStN2oSUDVGZC47mgwSSRbNYqs+JYoB4knz9MBKJQ="
+  "encryptionKey": "vAps8A/VDRAmnGak+c0t1A+4rUjw1mAmiI722fj2tBU="
 }

package/web/.next/standalone/src/presentation/web/app/actions/approve-feature.ts

@@ -0,0 +1,38 @@
+'use server';
+
+import { resolve } from '@/lib/server-container';
+import type { ApproveAgentRunUseCase } from '@shepai/core/application/use-cases/agents/approve-agent-run.use-case';
+import type { IFeatureRepository } from '@shepai/core/application/ports/output/repositories/feature-repository.interface';
+
+export async function approveFeature(
+  featureId: string
+): Promise<{ approved: boolean; error?: string }> {
+  if (!featureId.trim()) {
+    return { approved: false, error: 'Feature id is required' };
+  }
+
+  try {
+    const featureRepo = resolve<IFeatureRepository>('IFeatureRepository');
+    const feature = await featureRepo.findById(featureId);
+
+    if (!feature) {
+      return { approved: false, error: 'Feature not found' };
+    }
+
+    if (!feature.agentRunId) {
+      return { approved: false, error: 'Feature has no agent run' };
+    }
+
+    const approveUseCase = resolve<ApproveAgentRunUseCase>('ApproveAgentRunUseCase');
+    const result = await approveUseCase.execute(feature.agentRunId);
+
+    if (!result.approved) {
+      return { approved: false, error: result.reason };
+    }
+
+    return { approved: true };
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : 'Failed to approve feature';
+    return { approved: false, error: message };
+  }
+}

package/web/.next/standalone/src/presentation/web/app/actions/create-feature.ts

@@ -0,0 +1,81 @@
+'use server';
+
+import { resolve } from '@/lib/server-container';
+import type { CreateFeatureUseCase } from '@shepai/core/application/use-cases/features/create/create-feature.use-case';
+import type { Feature } from '@shepai/core/domain/generated/output';
+
+interface Attachment {
+  path: string;
+  name: string;
+}
+
+interface ApprovalGates {
+  allowPrd: boolean;
+  allowPlan: boolean;
+  allowMerge: boolean;
+}
+
+interface CreateFeatureInput {
+  name: string;
+  description?: string;
+  repositoryPath: string;
+  attachments?: Attachment[];
+  approvalGates?: {
+    allowPrd: boolean;
+    allowPlan: boolean;
+    allowMerge?: boolean;
+  };
+}
+
+function composeUserInput(
+  name: string,
+  description: string | undefined,
+  attachments: Attachment[] | undefined
+): string {
+  let userInput = `Feature: ${name}`;
+
+  if (description) {
+    userInput += `\n\n${description}`;
+  }
+
+  if (attachments && attachments.length > 0) {
+    const paths = attachments.map((a) => `- ${a.path}`).join('\n');
+    userInput += `\n\nAttached files:\n${paths}`;
+  }
+
+  return userInput;
+}
+
+export async function createFeature(
+  input: CreateFeatureInput
+): Promise<{ feature?: Feature; error?: string }> {
+  const { name, description, repositoryPath, attachments, approvalGates } = input;
+
+  if (!name?.trim()) {
+    return { error: 'name is required' };
+  }
+
+  if (!repositoryPath?.trim()) {
+    return { error: 'repositoryPath is required' };
+  }
+
+  const userInput = composeUserInput(name, description, attachments);
+  const gates: ApprovalGates = {
+    allowPrd: approvalGates?.allowPrd ?? false,
+    allowPlan: approvalGates?.allowPlan ?? false,
+    allowMerge: approvalGates?.allowMerge ?? false,
+  };
+
+  try {
+    const createFeatureUseCase = resolve<CreateFeatureUseCase>('CreateFeatureUseCase');
+    const result = await createFeatureUseCase.execute({
+      userInput,
+      repositoryPath,
+      approvalGates: gates,
+    });
+    return { feature: result.feature };
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : 'Failed to create feature';
+    return { error: message };
+  }
+}

package/web/.next/standalone/src/presentation/web/app/actions/delete-feature.ts

@@ -0,0 +1,22 @@
+'use server';
+
+import { resolve } from '@/lib/server-container';
+import type { DeleteFeatureUseCase } from '@shepai/core/application/use-cases/features/delete-feature.use-case';
+import type { Feature } from '@shepai/core/domain/generated/output';
+
+export async function deleteFeature(
+  featureId: string
+): Promise<{ feature?: Feature; error?: string }> {
+  if (!featureId?.trim()) {
+    return { error: 'id is required' };
+  }
+
+  try {
+    const deleteFeatureUseCase = resolve<DeleteFeatureUseCase>('DeleteFeatureUseCase');
+    const feature = await deleteFeatureUseCase.execute(featureId);
+    return { feature };
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : 'Failed to delete feature';
+    return { error: message };
+  }
+}

package/web/.next/standalone/src/presentation/web/app/actions/get-feature-artifact.ts

@@ -0,0 +1,55 @@
+'use server';
+
+import { resolve } from '@/lib/server-container';
+import type { GetFeatureArtifactUseCase } from '@shepai/core/application/use-cases/features/get-feature-artifact.use-case';
+import type { FeatureArtifact } from '@shepai/core/domain/generated/output';
+import type { PrdQuestionnaireData } from '@shepai/core/domain/generated/output';
+
+interface GetFeatureArtifactResult {
+  questionnaire?: PrdQuestionnaireData;
+  artifact?: FeatureArtifact;
+  error?: string;
+}
+
+/**
+ * Map FeatureArtifact openQuestions into the PrdQuestionnaireData shape
+ * expected by the PrdQuestionnaireDrawer component.
+ */
+function toQuestionnaireData(artifact: FeatureArtifact): PrdQuestionnaireData {
+  return {
+    question: 'Goal',
+    context: artifact.oneLiner,
+    questions: artifact.openQuestions.map((oq, idx) => ({
+      id: `q-${idx}`,
+      question: oq.question,
+      type: 'select' as const,
+      options: (oq.options ?? []).map((opt, optIdx) => ({
+        id: `q-${idx}-opt-${optIdx}`,
+        label: opt.option,
+        rationale: opt.description,
+        ...(opt.selected ? { recommended: true } : {}),
+      })),
+    })),
+    finalAction: {
+      id: 'approve-reqs',
+      label: 'Approve Requirements',
+      description: 'Finalize and lock the requirements for implementation',
+    },
+  };
+}
+
+export async function getFeatureArtifact(featureId: string): Promise<GetFeatureArtifactResult> {
+  if (!featureId.trim()) {
+    return { error: 'Feature id is required' };
+  }
+
+  try {
+    const useCase = resolve<GetFeatureArtifactUseCase>('GetFeatureArtifactUseCase');
+    const artifact = await useCase.execute(featureId);
+    const questionnaire = toQuestionnaireData(artifact);
+    return { questionnaire, artifact };
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : 'Failed to load feature artifact';
+    return { error: message };
+  }
+}

package/web/.next/standalone/src/presentation/web/app/actions/get-research-artifact.ts

@@ -0,0 +1,42 @@
+'use server';
+
+import { resolve } from '@/lib/server-container';
+import type { GetResearchArtifactUseCase } from '@shepai/core/application/use-cases/features/get-research-artifact.use-case';
+import type { ResearchArtifact, TechDecision } from '@shepai/core/domain/generated/output';
+
+export interface TechDecisionsReviewData {
+  name: string;
+  summary: string;
+  decisions: TechDecision[];
+  technologies: string[];
+}
+
+interface GetResearchArtifactResult {
+  techDecisions?: TechDecisionsReviewData;
+  error?: string;
+}
+
+function toTechDecisionsData(artifact: ResearchArtifact): TechDecisionsReviewData {
+  return {
+    name: artifact.name,
+    summary: artifact.summary,
+    decisions: artifact.decisions,
+    technologies: artifact.technologies,
+  };
+}
+
+export async function getResearchArtifact(featureId: string): Promise<GetResearchArtifactResult> {
+  if (!featureId.trim()) {
+    return { error: 'Feature id is required' };
+  }
+
+  try {
+    const useCase = resolve<GetResearchArtifactUseCase>('GetResearchArtifactUseCase');
+    const artifact = await useCase.execute(featureId);
+    const techDecisions = toTechDecisionsData(artifact);
+    return { techDecisions };
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : 'Failed to load research artifact';
+    return { error: message };
+  }
+}

package/web/.next/standalone/src/presentation/web/app/actions/open-folder.ts

@@ -0,0 +1,44 @@
+'use server';
+
+import { existsSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+
+export async function openFolder(
+  repositoryPath: string
+): Promise<{ success: boolean; error?: string; path?: string }> {
+  if (!repositoryPath?.startsWith('/')) {
+    return { success: false, error: 'repositoryPath must be an absolute path' };
+  }
+
+  try {
+    if (!existsSync(repositoryPath)) {
+      return { success: false, error: 'Directory not found' };
+    }
+
+    const platform = process.platform;
+
+    if (platform === 'darwin') {
+      const child = spawn('open', [repositoryPath], {
+        detached: true,
+        stdio: 'ignore',
+      });
+      child.unref();
+    } else if (platform === 'linux') {
+      const child = spawn('xdg-open', [repositoryPath], {
+        detached: true,
+        stdio: 'ignore',
+      });
+      child.unref();
+    } else {
+      return {
+        success: false,
+        error: `Unsupported platform: ${platform}. Folder open is supported on macOS and Linux only.`,
+      };
+    }
+
+    return { success: true, path: repositoryPath };
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : 'Failed to open folder';
+    return { success: false, error: message };
+  }
+}

package/web/.next/standalone/src/presentation/web/app/actions/open-ide.ts

@@ -0,0 +1,37 @@
+'use server';
+
+import { getSettings } from '@shepai/core/infrastructure/services/settings.service';
+import type { LaunchIdeUseCase } from '@shepai/core/application/use-cases/ide/launch-ide.use-case';
+import { resolve } from '@/lib/server-container';
+
+interface OpenIdeInput {
+  repositoryPath: string;
+  branch?: string;
+}
+
+export async function openIde(
+  input: OpenIdeInput
+): Promise<{ success: boolean; error?: string; editor?: string; path?: string }> {
+  const { repositoryPath, branch } = input;
+
+  if (!repositoryPath?.startsWith('/')) {
+    return { success: false, error: 'repositoryPath must be an absolute path' };
+  }
+
+  const settings = getSettings();
+  const editor = settings.environment.defaultEditor;
+
+  const useCase = resolve<LaunchIdeUseCase>('LaunchIdeUseCase');
+  const result = await useCase.execute({
+    editorId: editor,
+    repositoryPath,
+    branch,
+    checkAvailability: true,
+  });
+
+  if (!result.ok) {
+    return { success: false, error: result.message };
+  }
+
+  return { success: true, editor: result.editorName, path: result.worktreePath };
+}

package/web/.next/standalone/src/presentation/web/app/{api/shell/open/route.ts → actions/open-shell.ts}

@@ -1,33 +1,31 @@
-import { NextResponse } from 'next/server';
+'use server';
+
 import { existsSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { getSettings } from '@shepai/core/infrastructure/services/settings.service';
 import { computeWorktreePath } from '@shepai/core/infrastructure/services/ide-launchers/compute-worktree-path';
-import { validateToolbarInput } from '../../validate-toolbar-input';
 
-export async function POST(request: Request) {
-  let body: unknown;
-  try {
-    body = await request.json();
-  } catch {
-    return NextResponse.json({ error: 'Invalid or missing JSON body' }, { status: 400 });
-  }
+interface OpenShellInput {
+  repositoryPath: string;
+  branch?: string;
+}
 
-  const validation = validateToolbarInput(body as Record<string, unknown>);
+export async function openShell(
+  input: OpenShellInput
+): Promise<{ success: boolean; error?: string; path?: string; shell?: string }> {
+  const { repositoryPath, branch } = input;
 
-  if ('error' in validation) {
-    return NextResponse.json({ error: validation.error }, { status: validation.status });
+  if (!repositoryPath?.startsWith('/')) {
+    return { success: false, error: 'repositoryPath must be an absolute path' };
   }
 
-  const { repositoryPath, branch } = validation;
-
   try {
     const settings = getSettings();
     const shell = settings.environment.shellPreference;
     const targetPath = branch ? computeWorktreePath(repositoryPath, branch) : repositoryPath;
 
     if (!existsSync(targetPath)) {
-      return NextResponse.json({ error: `Path does not exist: ${targetPath}` }, { status: 404 });
+      return { success: false, error: `Path does not exist: ${targetPath}` };
     }
 
     const platform = process.platform;
@@ -45,21 +43,15 @@ export async function POST(request: Request) {
       });
       child.unref();
     } else {
-      return NextResponse.json(
-        {
-          error: `Unsupported platform: ${platform}. Shell launch is supported on macOS and Linux only.`,
-        },
-        { status: 501 }
-      );
+      return {
+        success: false,
+        error: `Unsupported platform: ${platform}. Shell launch is supported on macOS and Linux only.`,
+      };
     }
 
-    return NextResponse.json({
-      success: true,
-      path: targetPath,
-      shell,
-    });
+    return { success: true, path: targetPath, shell };
   } catch (error: unknown) {
     const message = error instanceof Error ? error.message : 'Failed to open shell';
-    return NextResponse.json({ error: message }, { status: 500 });
+    return { success: false, error: message };
   }
 }

package/web/.next/standalone/src/presentation/web/app/{api/dialog/pick-folder/route.ts → actions/pick-folder.ts}

@@ -1,19 +1,15 @@
-import { NextResponse } from 'next/server';
+'use server';
+
 import { FolderDialogService } from '@shepai/core/infrastructure/services/folder-dialog.service';
 
-export async function POST() {
+export async function pickFolder(): Promise<{ path: string | null; error?: string }> {
   const service = new FolderDialogService();
 
   try {
     const path = service.pickFolder();
-
-    if (path === null) {
-      return NextResponse.json({ path: null, cancelled: true });
-    }
-
-    return NextResponse.json({ path, cancelled: false });
+    return { path };
   } catch (error: unknown) {
     const message = error instanceof Error ? error.message : 'Failed to open folder dialog';
-    return NextResponse.json({ error: message }, { status: 500 });
+    return { path: null, error: message };
   }
 }

package/web/.next/standalone/src/presentation/web/app/api/agent-events/route.ts

@@ -4,17 +4,14 @@
  * Streams agent lifecycle notification events to connected web UI clients
  * via Server-Sent Events (SSE). This is the first API route in the web UI.
  *
- * - Subscribes to the notification event bus (shared in-process singleton)
+ * - Subscribes to the notification event bus (lazy-initialized singleton)
  * - Formats events as SSE data frames (event: notification\ndata: JSON\n\n)
  * - Sends heartbeat comments every 30 seconds to keep connection alive
  * - Supports optional ?runId query parameter to filter events
  * - Cleans up listeners and intervals on client disconnect
  */
 
-import {
-  getNotificationBus,
-  hasNotificationBus,
-} from '@shepai/core/infrastructure/services/notifications/notification-bus';
+import { getNotificationBus } from '@shepai/core/infrastructure/services/notifications/notification-bus';
 import type { NotificationEvent } from '@shepai/core/domain/generated/output';
 
 const HEARTBEAT_INTERVAL_MS = 30_000;
@@ -34,18 +31,9 @@ export function GET(request: Request): Response {
   const stream = new ReadableStream<Uint8Array>({
     start(controller) {
       const encoder = new TextEncoder();
-
-      // Check if bus is available
-      if (!hasNotificationBus()) {
-        controller.close();
-        return;
-      }
-
       const bus = getNotificationBus();
 
-      // Notification event listener
       const onNotification = (event: NotificationEvent) => {
-        // Apply runId filter if set
         if (runIdFilter && event.agentRunId !== runIdFilter) {
           return;
         }

package/web/.next/standalone/src/presentation/web/app/api/dialog/pick-files/route.ts

@@ -1,19 +1,17 @@
 import { NextResponse } from 'next/server';
-import { FileDialogService } from '@shepai/core/infrastructure/services/file-dialog.service';
+import {
+  FileDialogService,
+  type FileAttachment,
+} from '@shepai/core/infrastructure/services/file-dialog.service';
 
-export async function POST() {
+export async function POST(): Promise<NextResponse> {
   const service = new FileDialogService();
 
   try {
-    const files = service.pickFiles();
-
-    if (files === null) {
-      return NextResponse.json({ files: null, cancelled: true });
-    }
-
-    return NextResponse.json({ files, cancelled: false });
+    const files: FileAttachment[] | null = service.pickFiles();
+    return NextResponse.json({ files, cancelled: files === null });
   } catch (error: unknown) {
     const message = error instanceof Error ? error.message : 'Failed to open file dialog';
-    return NextResponse.json({ error: message }, { status: 500 });
+    return NextResponse.json({ files: null, cancelled: false, error: message }, { status: 500 });
   }
 }

package/web/.next/standalone/src/presentation/web/app/globals.css

@@ -71,6 +71,7 @@
   --animate-accordion-up: accordion-up 0.2s ease-out;
   --animate-spinner: spinner 0.8s linear infinite;
   --animate-indeterminate-progress: indeterminate-progress 1.5s ease-in-out infinite;
+  --animate-option-highlight: option-highlight 1.5s ease-out;
 }
 
 /* Dark Mode Theme Overrides */
@@ -141,6 +142,15 @@
   }
 }
 
+@keyframes option-highlight {
+  0% {
+    background-color: #ecfdf5;
+  }
+  100% {
+    background-color: transparent;
+  }
+}
+
 /* Sidebar Theme Variables */
 :root {
   --sidebar: var(--color-background);

package/web/.next/standalone/src/presentation/web/app/page.tsx

@@ -83,6 +83,7 @@ export default async function HomePage() {
         lifecycle,
         repositoryPath: feature.repositoryPath,
         branch: feature.branch,
+        specPath: feature.specPath,
         state: deriveNodeState(feature, run),
         progress: deriveProgress(feature),
         ...(run?.agentType && { agentType: run.agentType as FeatureNodeData['agentType'] }),