@shepai/cli 1.70.2 → 1.72.0

package/web/.next/standalone/src/presentation/web/app/(dashboard)/@drawer/create/page.tsx

@@ -0,0 +1,35 @@
+import { resolve } from '@/lib/server-container';
+import type { ListFeaturesUseCase } from '@shepai/core/application/use-cases/features/list-features.use-case';
+import { getWorkflowDefaults } from '@/app/actions/get-workflow-defaults';
+import { CreateDrawerClient } from '@/components/common/control-center-drawer/create-drawer-client';
+
+/** Skip static pre-rendering since we need runtime DI container. */
+export const dynamic = 'force-dynamic';
+
+interface CreateDrawerPageProps {
+  searchParams: Promise<{ repo?: string; parent?: string }>;
+}
+
+export default async function CreateDrawerPage({ searchParams }: CreateDrawerPageProps) {
+  const { repo, parent } = await searchParams;
+
+  const listFeatures = resolve<ListFeaturesUseCase>('ListFeaturesUseCase');
+
+  const [features, workflowDefaults] = await Promise.all([
+    listFeatures.execute(),
+    getWorkflowDefaults().catch(() => undefined),
+  ]);
+
+  const featureOptions = features
+    .map((f) => ({ id: f.id, name: f.name }))
+    .filter((f) => f.id && !f.id.startsWith('#'));
+
+  return (
+    <CreateDrawerClient
+      repositoryPath={repo ?? ''}
+      initialParentId={parent}
+      features={featureOptions}
+      workflowDefaults={workflowDefaults}
+    />
+  );
+}

package/web/.next/standalone/src/presentation/web/app/(dashboard)/@drawer/default.tsx

@@ -0,0 +1,4 @@
+/** No drawer when the URL doesn't match any drawer route (e.g. `/`). */
+export default function DrawerDefault() {
+  return null;
+}

package/web/.next/standalone/src/presentation/web/app/(dashboard)/@drawer/feature/[featureId]/page.tsx

@@ -0,0 +1,46 @@
+import { resolve } from '@/lib/server-container';
+import type { IFeatureRepository } from '@shepai/core/application/ports/output/repositories/feature-repository.interface';
+import type { IAgentRunRepository } from '@shepai/core/application/ports/output/agents/agent-run-repository.interface';
+import { buildFeatureNodeData } from '@/app/build-feature-node-data';
+import { computeDrawerView } from '@/components/common/control-center-drawer/drawer-view';
+import { FeatureDrawerClient } from '@/components/common/control-center-drawer/feature-drawer-client';
+
+/** Skip static pre-rendering since we need runtime DI container. */
+export const dynamic = 'force-dynamic';
+
+interface FeatureDrawerPageProps {
+  params: Promise<{ featureId: string }>;
+}
+
+export default async function FeatureDrawerPage({ params }: FeatureDrawerPageProps) {
+  const { featureId } = await params;
+
+  try {
+    const featureRepo = resolve<IFeatureRepository>('IFeatureRepository');
+    const agentRunRepo = resolve<IAgentRunRepository>('IAgentRunRepository');
+
+    const feature = await featureRepo.findById(featureId);
+    if (!feature) return null;
+
+    const run = feature.agentRunId ? await agentRunRepo.findById(feature.agentRunId) : null;
+
+    const nodeData = buildFeatureNodeData(feature, run);
+
+    const view = computeDrawerView({
+      selectedNode: nodeData,
+      isCreateDrawerOpen: false,
+      pendingRepositoryPath: '',
+      pendingParentFeatureId: undefined,
+      selectedRepoNode: null,
+      features: [],
+      workflowDefaults: undefined,
+    });
+
+    if (!view) return null;
+
+    return <FeatureDrawerClient view={view} />;
+  } catch {
+    // Feature not found — render nothing (drawer stays closed)
+    return null;
+  }
+}

package/web/.next/standalone/src/presentation/web/app/(dashboard)/@drawer/repository/[repositoryId]/page.tsx

@@ -0,0 +1,29 @@
+import { resolve } from '@/lib/server-container';
+import type { IRepositoryRepository } from '@shepai/core/application/ports/output/repositories/repository-repository.interface';
+import { RepositoryDrawerClient } from '@/components/common/control-center-drawer/repository-drawer-client';
+
+/** Skip static pre-rendering since we need runtime DI container. */
+export const dynamic = 'force-dynamic';
+
+interface RepositoryDrawerPageProps {
+  params: Promise<{ repositoryId: string }>;
+}
+
+export default async function RepositoryDrawerPage({ params }: RepositoryDrawerPageProps) {
+  const { repositoryId } = await params;
+
+  try {
+    const repoRepository = resolve<IRepositoryRepository>('IRepositoryRepository');
+    const repository = await repoRepository.findById(repositoryId);
+
+    if (!repository) return null;
+
+    return (
+      <RepositoryDrawerClient
+        data={{ name: repository.name, repositoryPath: repository.path, id: repository.id }}
+      />
+    );
+  } catch {
+    return null;
+  }
+}

package/web/.next/standalone/src/presentation/web/app/(dashboard)/create/page.tsx

@@ -0,0 +1,4 @@
+/** Children slot stub — canvas is rendered by the layout. */
+export default function CreatePage() {
+  return null;
+}

package/web/.next/standalone/src/presentation/web/app/(dashboard)/feature/[featureId]/page.tsx

@@ -0,0 +1,4 @@
+/** Children slot stub — canvas is rendered by the layout. */
+export default function FeaturePage() {
+  return null;
+}

package/web/.next/standalone/src/presentation/web/app/{page.tsx → (dashboard)/get-graph-data.ts}

@@ -1,15 +1,13 @@
-import { ControlCenter } from '@/components/features/control-center';
 import { resolve } from '@/lib/server-container';
 import type { ListFeaturesUseCase } from '@shepai/core/application/use-cases/features/list-features.use-case';
 import type { ListRepositoriesUseCase } from '@shepai/core/application/use-cases/repositories/list-repositories.use-case';
 import type { IAgentRunRepository } from '@shepai/core/application/ports/output/agents/agent-run-repository.interface';
 import { layoutWithDagre } from '@/lib/layout-with-dagre';
 import { buildGraphNodes } from '@/app/build-graph-nodes';
+import type { CanvasNodeType } from '@/components/features/features-canvas';
+import type { Edge } from '@xyflow/react';
 
-/** Skip static pre-rendering since we need runtime DI container and server context. */
-export const dynamic = 'force-dynamic';
-
-export default async function HomePage() {
+export async function getGraphData(): Promise<{ nodes: CanvasNodeType[]; edges: Edge[] }> {
   const listFeatures = resolve<ListFeaturesUseCase>('ListFeaturesUseCase');
   const listRepos = resolve<ListRepositoriesUseCase>('ListRepositoriesUseCase');
   const agentRunRepo = resolve<IAgentRunRepository>('IAgentRunRepository');
@@ -25,16 +23,9 @@ export default async function HomePage() {
 
   const { nodes, edges } = buildGraphNodes(repositories, featuresWithRuns);
 
-  // Use dagre LR layout for compact, automatic positioning
-  const laid = layoutWithDagre(nodes, edges, {
+  return layoutWithDagre(nodes, edges, {
     direction: 'LR',
     ranksep: 200,
     nodesep: 15,
   });
-
-  return (
-    <div className="h-screen w-full">
-      <ControlCenter initialNodes={laid.nodes} initialEdges={laid.edges} />
-    </div>
-  );
 }

package/web/.next/standalone/src/presentation/web/app/(dashboard)/layout.tsx

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+import { ControlCenter } from '@/components/features/control-center';
+import { getGraphData } from './get-graph-data';
+
+/** Skip static pre-rendering since we need runtime DI container and server context. */
+export const dynamic = 'force-dynamic';
+
+interface DashboardLayoutProps {
+  children: ReactNode;
+  drawer: ReactNode;
+}
+
+export default async function DashboardLayout({ children, drawer }: DashboardLayoutProps) {
+  const { nodes, edges } = await getGraphData();
+
+  return (
+    <div className="h-screen w-full">
+      <ControlCenter initialNodes={nodes} initialEdges={edges} drawer={drawer} />
+      {children}
+    </div>
+  );
+}

package/web/.next/standalone/src/presentation/web/app/(dashboard)/page.tsx

@@ -0,0 +1,7 @@
+/** Skip static pre-rendering since we need runtime DI container and server context. */
+export const dynamic = 'force-dynamic';
+
+/** Canvas is rendered by the layout; this page is just a route target for `/`. */
+export default function HomePage() {
+  return null;
+}

package/web/.next/standalone/src/presentation/web/app/(dashboard)/repository/[repositoryId]/page.tsx

@@ -0,0 +1,4 @@
+/** Children slot stub — canvas is rendered by the layout. */
+export default function RepositoryPage() {
+  return null;
+}

package/web/.next/standalone/src/presentation/web/app/actions/get-deployment-logs.ts

@@ -0,0 +1,16 @@
+'use server';
+
+import { resolve } from '@/lib/server-container';
+import type {
+  IDeploymentService,
+  LogEntry,
+} from '@shepai/core/application/ports/output/services/deployment-service.interface';
+
+export async function getDeploymentLogs(targetId: string): Promise<LogEntry[] | null> {
+  if (!targetId?.trim()) {
+    return null;
+  }
+
+  const deploymentService = resolve<IDeploymentService>('IDeploymentService');
+  return deploymentService.getLogs(targetId);
+}

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

@@ -4,9 +4,11 @@ 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';
+import type { ProductDecisionsSummaryData } from '@/components/common/product-decisions-summary';
 
 interface GetFeatureArtifactResult {
   questionnaire?: PrdQuestionnaireData;
+  productDecisions?: ProductDecisionsSummaryData;
   artifact?: FeatureArtifact;
   error?: string;
 }
@@ -38,6 +40,28 @@ function toQuestionnaireData(artifact: FeatureArtifact): PrdQuestionnaireData {
   };
 }
 
+/**
+ * Map FeatureArtifact openQuestions into a read-only summary for the
+ * Product Decisions tab in the tech review drawer.
+ */
+function toProductDecisionsData(artifact: FeatureArtifact): ProductDecisionsSummaryData {
+  return {
+    question: 'Goal',
+    context: artifact.oneLiner,
+    questions: artifact.openQuestions
+      .filter((oq) => oq.resolved)
+      .map((oq) => {
+        const selected = oq.options?.find((o) => o.selected);
+        return {
+          question: oq.question,
+          selectedOption: selected?.option ?? oq.answer ?? 'N/A',
+          rationale: oq.selectionRationale ?? selected?.description ?? '',
+          wasRecommended: false,
+        };
+      }),
+  };
+}
+
 export async function getFeatureArtifact(featureId: string): Promise<GetFeatureArtifactResult> {
   if (!featureId.trim()) {
     return { error: 'Feature id is required' };
@@ -47,7 +71,8 @@ export async function getFeatureArtifact(featureId: string): Promise<GetFeatureA
     const useCase = resolve<GetFeatureArtifactUseCase>('GetFeatureArtifactUseCase');
     const artifact = await useCase.execute(featureId);
     const questionnaire = toQuestionnaireData(artifact);
-    return { questionnaire, artifact };
+    const productDecisions = toProductDecisionsData(artifact);
+    return { questionnaire, productDecisions, 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/api/deployment-logs/route.ts

@@ -0,0 +1,112 @@
+/**
+ * SSE API Route: GET /api/deployment-logs
+ *
+ * Streams deployment log events to the client via Server-Sent Events.
+ * Subscribes to the DeploymentService EventEmitter for real-time log
+ * entries, filtered by targetId.
+ *
+ * - Accepts ?targetId query parameter (required)
+ * - Sends log entries as SSE "log" events
+ * - Sends heartbeat comments every 30 seconds to keep connection alive
+ * - Cleans up EventEmitter subscription on client disconnect
+ */
+
+import { resolve } from '@/lib/server-container';
+import type {
+  IDeploymentService,
+  LogEntry,
+} from '@shepai/core/application/ports/output/services/deployment-service.interface';
+
+// Force dynamic — SSE streams must never be statically optimized or cached
+export const dynamic = 'force-dynamic';
+
+const HEARTBEAT_INTERVAL_MS = 30_000;
+
+export function GET(request: Request): Response {
+  try {
+    const url = new URL(request.url);
+    const targetId = url.searchParams.get('targetId');
+
+    if (!targetId?.trim()) {
+      const errorStream = new ReadableStream<Uint8Array>({
+        start(controller) {
+          const encoder = new TextEncoder();
+          controller.enqueue(
+            encoder.encode(
+              `event: error\ndata: ${JSON.stringify({ error: 'targetId is required' })}\n\n`
+            )
+          );
+          controller.close();
+        },
+      });
+
+      return new Response(errorStream, {
+        headers: {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          Connection: 'keep-alive',
+        },
+      });
+    }
+
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        const encoder = new TextEncoder();
+        let stopped = false;
+
+        function enqueue(text: string) {
+          if (stopped) return;
+          try {
+            controller.enqueue(encoder.encode(text));
+          } catch {
+            // Stream may be closed
+          }
+        }
+
+        const deploymentService = resolve<IDeploymentService>('IDeploymentService');
+
+        // Subscribe to log events, filtering by targetId
+        const logHandler = (entry: LogEntry) => {
+          if (entry.targetId !== targetId) return;
+          enqueue(`event: log\ndata: ${JSON.stringify(entry)}\n\n`);
+        };
+
+        deploymentService.on('log', logHandler);
+
+        // Heartbeat to keep connection alive
+        const heartbeatInterval = setInterval(() => {
+          enqueue(': heartbeat\n\n');
+        }, HEARTBEAT_INTERVAL_MS);
+
+        // Cleanup on client disconnect
+        const cleanup = () => {
+          stopped = true;
+          deploymentService.off('log', logHandler);
+          clearInterval(heartbeatInterval);
+          try {
+            controller.close();
+          } catch {
+            // Stream may already be closed
+          }
+        };
+
+        request.signal.addEventListener('abort', cleanup, { once: true });
+      },
+    });
+
+    return new Response(stream, {
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      },
+    });
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error('[SSE route] GET /api/deployment-logs error:', error);
+    return new Response(JSON.stringify({ error: String(error) }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+}

package/web/.next/standalone/src/presentation/web/app/build-feature-node-data.ts

@@ -0,0 +1,63 @@
+import type { Feature, AgentRun } from '@shepai/core/domain/generated/output';
+import {
+  deriveNodeState,
+  deriveProgress,
+} from '@/components/common/feature-node/derive-feature-state';
+import type { FeatureNodeData, FeatureLifecyclePhase } from '@/components/common/feature-node';
+
+/** Map domain SdlcLifecycle enum values to UI FeatureLifecyclePhase (1:1). */
+const lifecycleMap: Record<string, FeatureLifecyclePhase> = {
+  Requirements: 'requirements',
+  Research: 'research',
+  Implementation: 'implementation',
+  Review: 'review',
+  'Deploy & QA': 'deploy',
+  Maintain: 'maintain',
+};
+
+/** Map agent graph node names (from agent_run.result) to UI lifecycle phases. */
+const nodeToLifecyclePhase: Record<string, FeatureLifecyclePhase> = {
+  analyze: 'requirements',
+  requirements: 'requirements',
+  research: 'research',
+  plan: 'implementation',
+  implement: 'implementation',
+  merge: 'review',
+};
+
+/**
+ * Builds a FeatureNodeData object from a Feature entity and optional AgentRun.
+ * This is the single-feature version of the logic in `buildGraphNodes`.
+ */
+export function buildFeatureNodeData(feature: Feature, run: AgentRun | null): FeatureNodeData {
+  const agentNode = run?.result?.startsWith('node:') ? run.result.slice(5) : undefined;
+  const lifecycle: FeatureLifecyclePhase =
+    run?.status === 'completed'
+      ? 'maintain'
+      : ((agentNode ? nodeToLifecyclePhase[agentNode] : undefined) ??
+        lifecycleMap[feature.lifecycle] ??
+        'requirements');
+
+  return {
+    name: feature.name,
+    description: feature.description ?? feature.slug,
+    featureId: feature.id,
+    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'] }),
+    ...(run?.error && { errorMessage: run.error }),
+    ...(feature.pr && {
+      pr: {
+        url: feature.pr.url,
+        number: feature.pr.number,
+        status: feature.pr.status,
+        ciStatus: feature.pr.ciStatus,
+        commitHash: feature.pr.commitHash,
+      },
+    }),
+  };
+}

package/web/.next/standalone/src/presentation/web/components/common/base-drawer/base-drawer.tsx

@@ -156,7 +156,11 @@ function DeployBar({ deployTarget }: { deployTarget: DeployActionInput }) {
         </Tooltip>
       </TooltipProvider>
       {isDeploymentActive ? (
-        <DeploymentStatusBadge status={deployAction.status} url={deployAction.url} />
+        <DeploymentStatusBadge
+          status={deployAction.status}
+          url={deployAction.url}
+          targetId={deployTarget.targetId}
+        />
       ) : null}
     </div>
   );

package/web/.next/standalone/src/presentation/web/components/common/control-center-drawer/control-center-drawer.tsx

@@ -51,7 +51,8 @@ import { ActionButton } from '@/components/common/action-button';
 import { OpenActionMenu } from '@/components/common/open-action-menu';
 import { FeatureCreateDrawer } from '@/components/common/feature-create-drawer';
 import { PrdQuestionnaire } from '@/components/common/prd-questionnaire';
-import { TechDecisionsReview } from '@/components/common/tech-decisions-review';
+import { TechReviewTabs } from '@/components/common/tech-review-tabs';
+import type { ProductDecisionsSummaryData } from '@/components/common/product-decisions-summary';
 import { MergeReview } from '@/components/common/merge-review';
 import { featureNodeStateConfig, lifecycleDisplayLabels } from '@/components/common/feature-node';
 import type { FeatureNodeData } from '@/components/common/feature-node';
@@ -89,6 +90,12 @@ export function ControlCenterDrawer({
   const [techData, setTechData] = useState<TechDecisionsReviewData | null>(null);
   const [isLoadingTech, setIsLoadingTech] = useState(false);
 
+  // ── Product decisions state (for tech review Product tab) ─────────────
+  const [techProductData, setTechProductData] = useState<
+    ProductDecisionsSummaryData | null | undefined
+  >(undefined);
+  const [isLoadingTechProduct, setIsLoadingTechProduct] = useState(false);
+
   // ── Merge review state ──────────────────────────────────────────────────
   const [mergeData, setMergeData] = useState<MergeReviewData | null>(null);
   const [isLoadingMerge, setIsLoadingMerge] = useState(false);
@@ -162,6 +169,32 @@ export function ControlCenterDrawer({
     };
   }, [techFeatureId]);
 
+  // Fetch product decisions for the Product tab in tech review
+  useEffect(() => {
+    setTechProductData(undefined);
+    if (!techFeatureId) return;
+
+    let cancelled = false;
+    setIsLoadingTechProduct(true);
+    getFeatureArtifact(techFeatureId)
+      .then((result) => {
+        if (cancelled) return;
+        if (result.productDecisions) {
+          setTechProductData(result.productDecisions);
+        }
+        // Silent failure — product tab shows "not available"
+      })
+      .catch(() => {
+        // Silent failure — the product tab is supplementary
+      })
+      .finally(() => {
+        if (!cancelled) setIsLoadingTechProduct(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [techFeatureId]);
+
   const mergeFeatureId = view?.type === 'merge-review' ? view.node.featureId : null;
   useEffect(() => {
     setMergeData(null);
@@ -381,7 +414,11 @@ export function ControlCenterDrawer({
                   </Tooltip>
                 </TooltipProvider>
                 {isFeatureDeployActive ? (
-                  <DeploymentStatusBadge status={deployAction.status} url={deployAction.url} />
+                  <DeploymentStatusBadge
+                    status={deployAction.status}
+                    url={deployAction.url}
+                    targetId={featureDeployTarget?.targetId}
+                  />
                 ) : null}
               </>
             ) : null}
@@ -508,8 +545,9 @@ export function ControlCenterDrawer({
     );
   } else if (view?.type === 'tech-review') {
     body = techData ? (
-      <TechDecisionsReview
-        data={techData}
+      <TechReviewTabs
+        techData={techData}
+        productData={isLoadingTechProduct ? null : techProductData}
         onApprove={handleTechApprove}
         onReject={handleTechReject}
         isProcessing={isLoadingTech}

package/web/.next/standalone/src/presentation/web/components/common/control-center-drawer/create-drawer-client.tsx

@@ -0,0 +1,87 @@
+'use client';
+
+import { useState, useCallback } from 'react';
+import { useRouter } from 'next/navigation';
+import { toast } from 'sonner';
+import { createFeature } from '@/app/actions/create-feature';
+import { FeatureCreateDrawer } from '@/components/common/feature-create-drawer';
+import type { FeatureCreatePayload } from '@/components/common/feature-create-drawer';
+import type { ParentFeatureOption } from '@/components/common/feature-create-drawer/feature-create-drawer';
+import type { WorkflowDefaults } from '@/app/actions/get-workflow-defaults';
+import { useSoundAction } from '@/hooks/use-sound-action';
+
+export interface CreateDrawerClientProps {
+  repositoryPath: string;
+  initialParentId?: string;
+  features: ParentFeatureOption[];
+  workflowDefaults?: WorkflowDefaults;
+}
+
+export function CreateDrawerClient({
+  repositoryPath,
+  initialParentId,
+  features,
+  workflowDefaults,
+}: CreateDrawerClientProps) {
+  const router = useRouter();
+  const createSound = useSoundAction('create');
+  const [isSubmitting, setIsSubmitting] = useState(false);
+
+  const onClose = useCallback(() => {
+    router.push('/');
+  }, [router]);
+
+  const onSubmit = useCallback(
+    (data: FeatureCreatePayload) => {
+      setIsSubmitting(true);
+
+      // Dispatch event for optimistic canvas update before navigating
+      window.dispatchEvent(
+        new CustomEvent('shep:feature-created', {
+          detail: {
+            name: data.name,
+            description: data.description,
+            repositoryPath: data.repositoryPath,
+          },
+        })
+      );
+
+      // Close the drawer immediately for responsive UI
+      router.push('/');
+
+      // Fire server action in the background
+      createFeature(data)
+        .then((result) => {
+          if (result.error) {
+            toast.error(result.error);
+            // Dispatch rollback event
+            window.dispatchEvent(new CustomEvent('shep:feature-create-failed'));
+            return;
+          }
+          createSound.play();
+          router.refresh();
+        })
+        .catch(() => {
+          toast.error('Failed to create feature');
+          window.dispatchEvent(new CustomEvent('shep:feature-create-failed'));
+        })
+        .finally(() => {
+          setIsSubmitting(false);
+        });
+    },
+    [router, createSound]
+  );
+
+  return (
+    <FeatureCreateDrawer
+      open
+      onClose={onClose}
+      onSubmit={onSubmit}
+      repositoryPath={repositoryPath}
+      features={features}
+      workflowDefaults={workflowDefaults}
+      initialParentId={initialParentId}
+      isSubmitting={isSubmitting}
+    />
+  );
+}