maestro-flow 0.1.4 → 0.2.1

package/dashboard/dist-server/dashboard/src/shared/types.d.ts

@@ -0,0 +1,223 @@
+export type PhaseStatus = 'not_started' | 'pending' | 'exploring' | 'planning' | 'executing' | 'verifying' | 'testing' | 'completed' | 'blocked';
+export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+export type TaskType = 'feature' | 'fix' | 'refactor' | 'test' | 'docs';
+export type ProjectStatus = 'planning' | 'executing' | 'verifying' | 'idle';
+import type { LinearIssue } from './linear-types.js';
+import type { Issue } from './issue-types.js';
+export type SelectedKanbanItem = {
+    type: 'phase';
+    phaseId: number;
+} | {
+    type: 'linearIssue';
+    issue: LinearIssue;
+} | {
+    type: 'issue';
+    issue: Issue;
+} | {
+    type: 'task';
+    task: TaskCard;
+    phaseId: number;
+};
+export type { AgentProcess, NormalizedEntry, ApprovalRequest, AgentStatusPayload, AgentStoppedPayload } from './agent-types.js';
+import type { AgentProcess, NormalizedEntry, ApprovalRequest, AgentStatusPayload, AgentStoppedPayload, AgentTurnCompletedPayload } from './agent-types.js';
+import type { SupervisorStatus } from './execution-types.js';
+import type { LearningStats } from './learning-types.js';
+import type { CommanderState, Decision, CommanderConfig, AssessMetrics } from './commander-types.js';
+import type { ExecutionStartedPayload, ExecutionCompletedPayload, ExecutionFailedPayload } from './ws-protocol.js';
+import type { CoordinateStatusPayload, CoordinateStepPayload, CoordinateAnalysisPayload, CoordinateClarificationPayload } from './coordinate-types.js';
+import type { RequirementProgressPayload, RequirementExpandedPayload, RequirementCommittedPayload, RequirementErrorPayload } from './requirement-types.js';
+import type { ScheduledTask } from './schedule-types.js';
+import type { ExtensionInfo } from './extension-types.js';
+import type { CollabMember, CollabActivityEntry } from './collab-types.js';
+export type SSEEventType = 'board:full' | 'phase:updated' | 'task:updated' | 'scratch:updated' | 'project:updated' | 'watcher:error' | 'heartbeat' | 'connected' | 'agent:spawned' | 'agent:entry' | 'agent:approval' | 'agent:status' | 'agent:stopped' | 'agent:turnCompleted' | 'execution:started' | 'execution:completed' | 'execution:failed' | 'execution:scheduler_status' | 'supervisor:status' | 'supervisor:learning_update' | 'supervisor:schedule_triggered' | 'supervisor:schedule_update' | 'supervisor:extension_loaded' | 'supervisor:extension_error' | 'commander:status' | 'commander:tick' | 'commander:decision' | 'commander:config' | 'commander:assess_metrics' | 'commander:error' | 'coordinate:status' | 'coordinate:analyze_metrics' | 'coordinate:step' | 'coordinate:analysis' | 'coordinate:clarification_needed' | 'coordinate:error' | 'requirement:expanded' | 'requirement:refined' | 'requirement:committed' | 'requirement:progress' | 'workspace:switched' | 'wiki:invalidated' | 'collab:members_updated' | 'collab:activity';
+/** Mirrors state.json — top-level project state */
+export interface ProjectState {
+    version: string;
+    project_name: string;
+    current_milestone: string;
+    current_phase: number;
+    status: ProjectStatus;
+    phases_summary: {
+        total: number;
+        completed: number;
+        in_progress: number;
+        pending: number;
+    };
+    last_updated: string;
+    accumulated_context: {
+        key_decisions: string[];
+        blockers: string[];
+        deferred: string[];
+    };
+}
+/** Mirrors index.json — one phase in the lifecycle pipeline */
+export interface PhaseCard {
+    phase: number;
+    slug: string;
+    title: string;
+    status: PhaseStatus;
+    created_at: string;
+    updated_at: string;
+    goal: string;
+    success_criteria: string[];
+    requirements: string[];
+    spec_ref: string | null;
+    plan: {
+        task_ids: string[];
+        task_count: number;
+        complexity: string | null;
+        waves: (string[] | {
+            wave: number;
+            tasks: string[];
+        })[];
+    };
+    execution: {
+        method: string;
+        started_at: string | null;
+        completed_at: string | null;
+        tasks_completed: number;
+        tasks_total: number;
+        current_wave: number;
+        commits: (string | {
+            hash: string;
+            task: string;
+            message: string;
+        })[];
+    };
+    verification: {
+        status: string;
+        verified_at: string | null;
+        must_haves: string[];
+        gaps: (string | {
+            id?: string;
+            severity?: string;
+            description?: string;
+        })[];
+    };
+    validation: {
+        status: string;
+        test_coverage: number | {
+            statements: number;
+            branches: number;
+            functions: number;
+            lines: number;
+        } | null;
+        gaps: (string | {
+            requirement?: string;
+            status?: string;
+            description?: string;
+        })[];
+    };
+    uat: {
+        status: string;
+        test_count: number;
+        passed: number;
+        gaps: (string | {
+            description?: string;
+        })[];
+    };
+    reflection: {
+        rounds: number;
+        strategy_adjustments: string[];
+    };
+}
+/** Mirrors TASK-*.json — a task within a phase */
+export interface TaskCard {
+    id: string;
+    title: string;
+    description: string;
+    type: TaskType;
+    priority: string;
+    effort: string;
+    action: string;
+    scope: string;
+    focus_paths: string[];
+    depends_on: string[];
+    parallel_group: string | null;
+    convergence: {
+        criteria: string[];
+        verification: string;
+        definition_of_done: string;
+    };
+    files: Array<{
+        path: string;
+        action: string;
+        target: string;
+        change: string;
+    }>;
+    implementation: string[];
+    test: {
+        commands: string[];
+        unit: string[];
+        integration: string[];
+        success_metrics: string[];
+    };
+    reference: {
+        pattern: string;
+        files: string[];
+        examples: string | null;
+    };
+    rationale: {
+        chosen_approach: string;
+        decision_factors: string[];
+        tradeoffs: string | null;
+    };
+    risks: string[];
+    code_skeleton: string | null;
+    doc_context: {
+        affected_features: string[];
+        affected_components: string[];
+        affected_requirements: string[];
+        adr_ids: string[];
+    };
+    meta: {
+        status: TaskStatus;
+        estimated_time: string | null;
+        risk: string;
+        autonomous: boolean;
+        checkpoint: boolean;
+        wave: number;
+        execution_group: string | null;
+        executor: string;
+    };
+}
+/** Non-phase scratch tasks (from scratch-index.json) */
+export interface ScratchCard {
+    id: string;
+    title: string;
+    status: TaskStatus;
+    type: TaskType;
+    created_at: string;
+    updated_at: string;
+    description: string;
+    files: string[];
+}
+/** Full board state — assembled by the server from .workflow/ files */
+export interface BoardState {
+    project: ProjectState;
+    phases: PhaseCard[];
+    scratch: ScratchCard[];
+    lastUpdated: string;
+}
+/** SSE event envelope */
+export interface SSEEvent {
+    type: SSEEventType;
+    data: BoardState | PhaseCard | TaskCard | ScratchCard | ProjectState | AgentProcess | NormalizedEntry | ApprovalRequest | AgentStatusPayload | AgentStoppedPayload | AgentTurnCompletedPayload | ExecutionStartedPayload | ExecutionCompletedPayload | ExecutionFailedPayload | SupervisorStatus | CommanderState | Decision | CommanderConfig | AssessMetrics | CoordinateStatusPayload | CoordinateStepPayload | CoordinateAnalysisPayload | CoordinateClarificationPayload | RequirementProgressPayload | RequirementExpandedPayload | RequirementCommittedPayload | RequirementErrorPayload | LearningStats | {
+        taskId: string;
+        taskName: string;
+        taskType: string;
+    } | {
+        tasks: ScheduledTask[];
+    } | {
+        extensions: ExtensionInfo[];
+    } | {
+        name: string;
+        error: string;
+    } | {
+        workspace: string;
+    } | {
+        at: number;
+        path?: string;
+    } | CollabMember[] | CollabActivityEntry | string | null;
+    timestamp: string;
+}

package/dashboard/dist-server/dashboard/src/shared/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/shared/types.ts"],"names":[],"mappings":""}

package/dashboard/dist-server/dashboard/src/shared/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/shared/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAEvC,6DAA6D;AAC7D,MAAM,UAAU,cAAc,CAAC,CAAS;IACtC,OAAO,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AACtC,CAAC"}

package/dashboard/dist-server/dashboard/src/shared/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dashboard/dist-server/dashboard/src/shared/utils.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.js","sourceRoot":"","sources":["../../../../src/shared/utils.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;IAC9B,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;QACjD,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;QAC1C,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAChD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sBAAsB,EAAE,GAAG,EAAE;QAC9B,MAAM,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE;QAChD,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;QACxC,MAAM,MAAM,GAAG,cAAc,CAAC,yBAAyB,CAAC,CAAC;QACzD,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAC9B,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dashboard/dist-server/dashboard/src/shared/wave-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave-types.js","sourceRoot":"","sources":["../../../../src/shared/wave-types.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,mEAAmE;AACnE,8EAA8E"}

package/dashboard/dist-server/dashboard/src/shared/ws-protocol.d.ts

@@ -0,0 +1,161 @@
+import type { AgentConfig, AgentProcess, AgentType, NormalizedEntry, ApprovalRequest, AgentStatusPayload, AgentStoppedPayload } from './agent-types.js';
+import type { CommanderConfig } from './commander-types.js';
+import type { SupervisorConfig } from './execution-types.js';
+import type { ExpansionDepth } from './requirement-types.js';
+/** All WebSocket event type discriminators */
+export type WsEventType = 'agent:spawned' | 'agent:entry' | 'agent:approval' | 'agent:status' | 'agent:stopped' | 'agent:turnCompleted' | 'agent:thought' | 'agent:streaming' | 'execution:started' | 'execution:completed' | 'execution:failed' | 'execution:scheduler_status' | 'supervisor:status' | 'supervisor:learning_update' | 'supervisor:schedule_triggered' | 'supervisor:schedule_update' | 'supervisor:extension_loaded' | 'supervisor:extension_error' | 'commander:status' | 'commander:tick' | 'commander:decision' | 'commander:config' | 'commander:assess_metrics' | 'commander:error' | 'coordinate:status' | 'coordinate:analyze_metrics' | 'coordinate:step' | 'coordinate:analysis' | 'coordinate:clarification_needed' | 'coordinate:error' | 'requirement:expanded' | 'requirement:refined' | 'requirement:committed' | 'requirement:progress' | 'board:full' | 'phase:updated' | 'task:updated' | 'scratch:updated' | 'project:updated' | 'watcher:error' | 'workspace:switched' | 'heartbeat' | 'connected' | 'wiki:invalidated' | 'collab:members_updated' | 'collab:activity';
+/** Envelope for all server-to-client WebSocket messages */
+export interface WsServerMessage<T = unknown> {
+    type: WsEventType;
+    data: T;
+    timestamp: string;
+}
+export type WsAgentSpawnedMessage = WsServerMessage<AgentProcess>;
+export type WsAgentEntryMessage = WsServerMessage<NormalizedEntry>;
+export type WsAgentApprovalMessage = WsServerMessage<ApprovalRequest>;
+export type WsAgentStatusMessage = WsServerMessage<AgentStatusPayload>;
+export type WsAgentStoppedMessage = WsServerMessage<AgentStoppedPayload>;
+/** Discriminated union of all client-to-server WS actions */
+export type WsClientMessage = WsClientSpawnMessage | WsClientStopMessage | WsClientMessageMessage | WsClientDelegateMessage | WsClientApproveMessage | WsClientCliBridgeSpawnMessage | WsClientCliBridgeEntryMessage | WsClientCliBridgeStoppedMessage | WsClientExecuteIssueMessage | WsClientExecuteBatchMessage | WsClientAnalyzeIssueMessage | WsClientPlanIssueMessage | WsClientSupervisorToggleMessage | WsClientCommanderStartMessage | WsClientCommanderStopMessage | WsClientCommanderPauseMessage | WsClientCommanderConfigMessage | WsClientWaveExecuteMessage | WsClientCoordinateStartMessage | WsClientCoordinateStopMessage | WsClientCoordinateResumeMessage | WsClientCoordinateClarifyMessage | WsClientIssuePipelineMessage | WsClientRequirementExpandMessage | WsClientRequirementRefineMessage | WsClientRequirementCommitMessage;
+export interface WsClientSpawnMessage {
+    action: 'spawn';
+    config: AgentConfig;
+}
+export interface WsClientStopMessage {
+    action: 'stop';
+    processId: string;
+}
+export interface WsClientMessageMessage {
+    action: 'message';
+    processId: string;
+    content: string;
+}
+export interface WsClientDelegateMessage {
+    action: 'delegate:message';
+    processId?: string;
+    execId?: string;
+    content: string;
+    delivery: 'inject' | 'after_complete';
+}
+export interface WsClientApproveMessage {
+    action: 'approve';
+    processId: string;
+    requestId: string;
+    allow: boolean;
+}
+export interface WsClientCliBridgeSpawnMessage {
+    action: 'cli:spawned';
+    process: AgentProcess;
+}
+export interface WsClientCliBridgeEntryMessage {
+    action: 'cli:entry';
+    entry: NormalizedEntry;
+}
+export interface WsClientCliBridgeStoppedMessage {
+    action: 'cli:stopped';
+    processId: string;
+}
+export interface WsClientExecuteIssueMessage {
+    action: 'execute:issue';
+    issueId: string;
+    executor?: AgentType;
+}
+export interface WsClientExecuteBatchMessage {
+    action: 'execute:batch';
+    issueIds: string[];
+    executor?: AgentType;
+    maxConcurrency?: number;
+}
+export interface WsClientAnalyzeIssueMessage {
+    action: 'issue:analyze';
+    issueId: string;
+    tool?: string;
+    depth?: string;
+}
+export interface WsClientPlanIssueMessage {
+    action: 'issue:plan';
+    issueId: string;
+    tool?: string;
+}
+export interface WsClientIssuePipelineMessage {
+    action: 'issue:pipeline';
+    issueId: string;
+    tool?: string;
+}
+export interface WsClientSupervisorToggleMessage {
+    action: 'supervisor:toggle';
+    enabled: boolean;
+    config?: Partial<SupervisorConfig>;
+}
+export interface WsClientCommanderStartMessage {
+    action: 'commander:start';
+}
+export interface WsClientCommanderStopMessage {
+    action: 'commander:stop';
+}
+export interface WsClientCommanderPauseMessage {
+    action: 'commander:pause';
+}
+export interface WsClientCommanderConfigMessage {
+    action: 'commander:config';
+    config: Partial<CommanderConfig>;
+}
+export interface WsClientWaveExecuteMessage {
+    action: 'execute:wave';
+    issueId: string;
+}
+export interface WsClientCoordinateStartMessage {
+    action: 'coordinate:start';
+    intent: string;
+    tool?: string;
+    autoMode?: boolean;
+}
+export interface WsClientCoordinateStopMessage {
+    action: 'coordinate:stop';
+}
+export interface WsClientCoordinateResumeMessage {
+    action: 'coordinate:resume';
+    sessionId?: string;
+}
+export interface WsClientCoordinateClarifyMessage {
+    action: 'coordinate:clarify';
+    sessionId: string;
+    response: string;
+}
+export interface WsClientRequirementExpandMessage {
+    action: 'requirement:expand';
+    text: string;
+    depth?: ExpansionDepth;
+    method?: 'sdk' | 'cli';
+}
+export interface WsClientRequirementRefineMessage {
+    action: 'requirement:refine';
+    requirementId: string;
+    feedback: string;
+}
+export interface WsClientRequirementCommitMessage {
+    action: 'requirement:commit';
+    requirementId: string;
+    mode: 'issues' | 'coordinate';
+}
+export interface ExecutionStartedPayload {
+    issueId: string;
+    processId: string;
+    executor: AgentType;
+    /** Optional: updated issue for incremental client-side update */
+    issue?: import('./issue-types.js').Issue;
+}
+export interface ExecutionCompletedPayload {
+    issueId: string;
+    processId: string;
+    /** Optional: updated issue for incremental client-side update */
+    issue?: import('./issue-types.js').Issue;
+}
+export interface ExecutionFailedPayload {
+    issueId: string;
+    processId: string;
+    error: string;
+    /** Optional: updated issue for incremental client-side update */
+    issue?: import('./issue-types.js').Issue;
+}
+export declare const WS_ENDPOINT = "/ws";

package/dashboard/dist-server/dashboard/src/shared/ws-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-protocol.js","sourceRoot":"","sources":["../../../../src/shared/ws-protocol.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,6DAA6D;AAC7D,8EAA8E;AA4T9E,8EAA8E;AAC9E,cAAc;AACd,8EAA8E;AAE9E,MAAM,CAAC,MAAM,WAAW,GAAG,KAAK,CAAC"}

package/dashboard/dist-server/shared/agent-types.d.ts

@@ -1,5 +1,5 @@
 /** Supported agent CLI types */
-export type AgentType = 'claude-code' | 'codex' | 'codex-server' | 'gemini' | 'qwen' | 'opencode' | 'agent-sdk';
+export type AgentType = 'claude-code' | 'codex' | 'codex-server' | 'gemini' | 'gemini-a2a' | 'qwen' | 'opencode' | 'agent-sdk';
 /** Agent process lifecycle status */
 export type AgentProcessStatus = 'spawning' | 'running' | 'paused' | 'stopping' | 'stopped' | 'error';
 /** Configuration for spawning an agent process */
@@ -15,6 +15,8 @@ export interface AgentConfig {
     settingsFile?: string;
     /** Path to .env file for loading environment variables before spawn */
     envFile?: string;
+    /** When true, spawn in interactive mode (stdin kept open for follow-up messages) */
+    interactive?: boolean;
 }
 /** Runtime state of a spawned agent process */
 export interface AgentProcess {

package/dashboard/dist-server/shared/agent-types.js

@@ -1,5 +1,8 @@
 // ---------------------------------------------------------------------------
 // Agent type system — protocol abstraction for CLI agent processes
+//
+// CANONICAL source of truth for all agent types. Both the maestro CLI (src/)
+// and dashboard (dashboard/src/) import from this file.
 // ---------------------------------------------------------------------------
 export {};
 //# sourceMappingURL=agent-types.js.map

package/dashboard/dist-server/shared/agent-types.js.map

@@ -1 +1 @@
-{"version":3,"file":"agent-types.js","sourceRoot":"","sources":["../../src/shared/agent-types.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,mEAAmE;AACnE,8EAA8E"}
+{"version":3,"file":"agent-types.js","sourceRoot":"","sources":["../../../shared/agent-types.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,mEAAmE;AACnE,EAAE;AACF,6EAA6E;AAC7E,wDAAwD;AACxD,8EAA8E"}

package/dashboard/dist-server/src/agents/cli-agent-runner.d.ts

@@ -0,0 +1,57 @@
+import { type DelegateBrokerApi } from '../async/index.js';
+import type { AgentType, AgentConfig, AgentProcess, NormalizedEntry } from '../../shared/agent-types.js';
+/** Minimal adapter interface matching BaseAgentAdapter's public surface */
+interface AdapterLike {
+    spawn(config: AgentConfig): Promise<AgentProcess>;
+    stop(processId: string): Promise<void>;
+    onEntry(processId: string, cb: (entry: NormalizedEntry) => void): () => void;
+    sendMessage?(processId: string, content: string): Promise<void>;
+    supportsInteractive?(): boolean;
+    endInput?(processId: string): void;
+}
+interface DashboardBridgeLike {
+    tryConnect(url: string, timeoutMs?: number): Promise<boolean>;
+    forwardSpawn(process: unknown): void;
+    forwardEntry(entry: unknown): void;
+    forwardStopped(processId: string): void;
+    close(): void;
+}
+export interface CliAgentRunnerDependencies {
+    brokerClient?: DelegateBrokerApi;
+    createAdapter?: (agentType: AgentType, backend?: 'direct' | 'terminal') => Promise<AdapterLike>;
+    createBridge?: () => DashboardBridgeLike;
+    spawnDetachedDelegate?: (options: CliRunOptions, execId: string, prompt: string) => boolean;
+    now?: () => string;
+    renderEntry?: (entry: NormalizedEntry) => void;
+}
+export interface CliRunOptions {
+    prompt: string;
+    tool: string;
+    mode: 'analysis' | 'write';
+    model?: string;
+    workDir: string;
+    rule?: string;
+    execId?: string;
+    resume?: string;
+    includeDirs?: string[];
+    sessionId?: string;
+    backend?: 'direct' | 'terminal';
+}
+export declare function generateCliExecId(tool: string): string;
+export declare class CliAgentRunner {
+    private readonly dependencies;
+    constructor(dependencies?: CliAgentRunnerDependencies);
+    /** Resolve dashboard WS URL from env → config → default port 3001 */
+    private static getDashboardWsUrl;
+    /**
+     * Send MCP channel notification (primary path).
+     * If maestro MCP server is running in this process, push a
+     * notifications/claude/channel message directly.
+     */
+    private static sendChannelNotification;
+    /**
+     * Run a CLI agent to completion and return its exit code (0 = success).
+     */
+    run(options: CliRunOptions): Promise<number>;
+}
+export {};