sessioncast-cli 2.0.0 → 2.0.2

package/dist/autopilot/workflow-generator.js

@@ -0,0 +1,278 @@
+"use strict";
+/**
+ * WorkflowGenerator - Convert mission analysis into executable workflow
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateWorkflow = generateWorkflow;
+exports.toExecutableWorkflow = toExecutableWorkflow;
+exports.createQuickWorkflow = createQuickWorkflow;
+const path = __importStar(require("path"));
+/**
+ * Generate workflow from mission analysis
+ */
+function generateWorkflow(analysis, context) {
+    // Generate unique workflow name
+    const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+    const workflowName = `autopilot-${timestamp}`;
+    // Determine required agents based on steps
+    const agents = createAgents(analysis.steps, context);
+    // Create workflow steps with proper IDs and dependencies
+    const steps = createSteps(analysis.steps, agents);
+    return {
+        name: workflowName,
+        mission: analysis.mission,
+        agents,
+        steps
+    };
+}
+/**
+ * Create agent configurations based on step types
+ */
+function createAgents(steps, context) {
+    const agentTypes = new Set();
+    for (const step of steps) {
+        agentTypes.add(step.type);
+    }
+    const agents = [];
+    for (const type of agentTypes) {
+        const agentId = `agent-${type}`;
+        const workDir = getWorkDirForType(type, context);
+        agents.push({
+            id: agentId,
+            name: getAgentName(type, context.projectType),
+            role: getAgentRole(type),
+            workingDir: workDir
+        });
+    }
+    // If only one agent, use a generic name
+    if (agents.length === 1) {
+        agents[0].name = `${context.projectName} Developer`;
+        agents[0].id = 'agent-main';
+    }
+    return agents;
+}
+/**
+ * Get working directory for agent type
+ */
+function getWorkDirForType(type, context) {
+    const { workingDir, projectType } = context;
+    switch (type) {
+        case 'frontend':
+            // React/Vue/Next projects might have frontend in root or src
+            if (['react', 'next', 'vue'].includes(projectType)) {
+                return workingDir;
+            }
+            // Full-stack projects might have separate frontend dir
+            return path.join(workingDir, 'frontend');
+        case 'backend':
+            if (['spring', 'go', 'rust', 'python', 'node'].includes(projectType)) {
+                return workingDir;
+            }
+            return path.join(workingDir, 'backend');
+        case 'mobile':
+            if (projectType === 'android') {
+                return path.join(workingDir, 'app');
+            }
+            if (projectType === 'ios') {
+                return workingDir;
+            }
+            return workingDir;
+        case 'infra':
+            return workingDir;
+        case 'test':
+            return workingDir;
+        case 'fullstack':
+        default:
+            return workingDir;
+    }
+}
+/**
+ * Get agent display name
+ */
+function getAgentName(type, projectType) {
+    const typeNames = {
+        frontend: 'Frontend Developer',
+        backend: 'Backend Developer',
+        fullstack: 'Full-Stack Developer',
+        mobile: getMobileAgentName(projectType),
+        infra: 'DevOps Engineer',
+        test: 'QA Engineer'
+    };
+    return typeNames[type];
+}
+/**
+ * Get mobile agent name based on platform
+ */
+function getMobileAgentName(projectType) {
+    if (projectType === 'android')
+        return 'Android Developer';
+    if (projectType === 'ios')
+        return 'iOS Developer';
+    return 'Mobile Developer';
+}
+/**
+ * Get agent role description
+ */
+function getAgentRole(type) {
+    const roles = {
+        frontend: 'Implements UI components and client-side logic',
+        backend: 'Implements server-side logic and APIs',
+        fullstack: 'Handles both frontend and backend development',
+        mobile: 'Develops mobile application features',
+        infra: 'Manages infrastructure and deployment',
+        test: 'Creates and runs tests'
+    };
+    return roles[type];
+}
+/**
+ * Create workflow steps from analyzed steps
+ */
+function createSteps(analyzedSteps, agents) {
+    const steps = [];
+    const stepIdMap = new Map();
+    // First pass: create steps and generate IDs
+    for (let i = 0; i < analyzedSteps.length; i++) {
+        const analyzed = analyzedSteps[i];
+        const stepId = `step-${i + 1}`;
+        stepIdMap.set(analyzed.name, stepId);
+        // Find the agent for this step type
+        const agent = findAgentForType(analyzed.type, agents);
+        steps.push({
+            id: stepId,
+            name: analyzed.name,
+            description: analyzed.description,
+            agentId: agent.id,
+            prompt: buildAgentPrompt(analyzed),
+            status: 'pending'
+        });
+    }
+    // Second pass: resolve dependencies
+    for (let i = 0; i < analyzedSteps.length; i++) {
+        const analyzed = analyzedSteps[i];
+        if (analyzed.dependsOn && analyzed.dependsOn.length > 0) {
+            steps[i].dependsOn = analyzed.dependsOn
+                .map(name => stepIdMap.get(name))
+                .filter((id) => id !== undefined);
+        }
+    }
+    return steps;
+}
+/**
+ * Find the appropriate agent for a step type
+ */
+function findAgentForType(type, agents) {
+    // First try exact match
+    const exact = agents.find(a => a.id === `agent-${type}`);
+    if (exact)
+        return exact;
+    // If only one agent, use it
+    if (agents.length === 1)
+        return agents[0];
+    // Fallback to fullstack or first available
+    const fullstack = agents.find(a => a.id === 'agent-fullstack');
+    return fullstack || agents[0];
+}
+/**
+ * Build detailed prompt for agent execution
+ */
+function buildAgentPrompt(step) {
+    let prompt = step.prompt;
+    // Add context if not already present
+    if (!prompt.toLowerCase().includes('step') && !prompt.toLowerCase().includes('task')) {
+        prompt = `Task: ${step.name}\n\n${step.description}\n\nDetails:\n${step.prompt}`;
+    }
+    return prompt;
+}
+/**
+ * Convert GeneratedWorkflow to existing Workflow format
+ */
+function toExecutableWorkflow(generated) {
+    // Group steps by agent
+    const agentTasks = new Map();
+    const agentDeps = new Map();
+    for (const step of generated.steps) {
+        const tasks = agentTasks.get(step.agentId) || [];
+        tasks.push(step.prompt);
+        agentTasks.set(step.agentId, tasks);
+        // Collect dependencies (other agents this agent depends on)
+        if (step.dependsOn) {
+            const deps = agentDeps.get(step.agentId) || new Set();
+            for (const depStepId of step.dependsOn) {
+                const depStep = generated.steps.find(s => s.id === depStepId);
+                if (depStep && depStep.agentId !== step.agentId) {
+                    deps.add(depStep.agentId);
+                }
+            }
+            agentDeps.set(step.agentId, deps);
+        }
+    }
+    return {
+        name: generated.name,
+        mission: generated.mission,
+        created: new Date().toISOString(),
+        agents: generated.agents.map(agent => ({
+            id: agent.id,
+            name: agent.name,
+            workDir: agent.workingDir,
+            tasks: agentTasks.get(agent.id) || [],
+            dependsOn: Array.from(agentDeps.get(agent.id) || [])
+        }))
+    };
+}
+/**
+ * Create a simple single-agent workflow for quick execution
+ */
+function createQuickWorkflow(prompt, context) {
+    const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+    return {
+        name: `quick-${timestamp}`,
+        mission: prompt,
+        agents: [{
+                id: 'agent-main',
+                name: `${context.projectName} Developer`,
+                role: 'Full-stack developer for this project',
+                workingDir: context.workingDir
+            }],
+        steps: [{
+                id: 'step-1',
+                name: 'Execute task',
+                description: prompt,
+                agentId: 'agent-main',
+                prompt: prompt,
+                status: 'pending'
+            }]
+    };
+}

package/dist/project/executor.d.ts

@@ -0,0 +1,73 @@
+import { EventEmitter } from 'events';
+import { ProjectManager } from './manager';
+export interface ExecutorOptions {
+    autoLaunchClaude?: boolean;
+    claudeCommand?: string;
+    relayUrl?: string;
+    relayToken?: string;
+}
+export declare class WorkflowExecutor extends EventEmitter {
+    private manager;
+    private workflow;
+    private running;
+    private pollTimer;
+    private options;
+    private relayClient;
+    constructor(manager: ProjectManager, options?: ExecutorOptions);
+    /**
+     * Start workflow execution
+     */
+    start(): Promise<void>;
+    /**
+     * Connect to relay server and register project
+     */
+    private connectToRelay;
+    /**
+     * Update relay with current agents list
+     */
+    private updateRelayAgents;
+    /**
+     * Start PM Agent tmux session
+     */
+    private startPMAgent;
+    /**
+     * Start a work agent
+     */
+    private startAgent;
+    /**
+     * Build task prompt for agent
+     */
+    private buildTaskPrompt;
+    /**
+     * Launch Claude Code CLI in a tmux session
+     */
+    private launchClaudeInSession;
+    /**
+     * Sleep helper
+     */
+    private sleep;
+    /**
+     * Main execution loop
+     */
+    private runExecutionLoop;
+    /**
+     * Stop workflow execution
+     */
+    stop(): void;
+    /**
+     * Kill all project tmux sessions
+     */
+    killAllSessions(): void;
+    /**
+     * Send keys to an agent session
+     */
+    sendToAgent(agentId: string, keys: string): boolean;
+    /**
+     * Capture agent terminal output
+     */
+    captureAgent(agentId: string): string | null;
+    /**
+     * List all agent sessions for this project
+     */
+    listSessions(): string[];
+}