@shepai/cli 1.71.0 → 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/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/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}
+    />
+  );
+}