sessioncast-cli 2.0.0 → 2.0.1

package/dist/autopilot/index.js

@@ -0,0 +1,322 @@
+"use strict";
+/**
+ * AutoPilot - Single-prompt execution layer for SessionCast
+ *
+ * Enables opencode-style experience: one prompt → auto-detect → auto-analyze → auto-execute
+ */
+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;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoPilot = exports.saveSpeckit = exports.generateQuickSpeckit = exports.generateSpeckit = void 0;
+exports.autoPilot = autoPilot;
+exports.autoPilotQuick = autoPilotQuick;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const events_1 = require("events");
+const project_detector_1 = require("./project-detector");
+const source_scanner_1 = require("./source-scanner");
+const mission_analyzer_1 = require("./mission-analyzer");
+const workflow_generator_1 = require("./workflow-generator");
+const speckit_generator_1 = require("./speckit-generator");
+// Re-export types
+__exportStar(require("./types"), exports);
+// Re-export Speckit functions
+var speckit_generator_2 = require("./speckit-generator");
+Object.defineProperty(exports, "generateSpeckit", { enumerable: true, get: function () { return speckit_generator_2.generateSpeckit; } });
+Object.defineProperty(exports, "generateQuickSpeckit", { enumerable: true, get: function () { return speckit_generator_2.generateQuickSpeckit; } });
+Object.defineProperty(exports, "saveSpeckit", { enumerable: true, get: function () { return speckit_generator_2.saveSpeckit; } });
+class AutoPilot extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.context = this.createInitialContext(options);
+    }
+    /**
+     * Create initial context
+     */
+    createInitialContext(options) {
+        return {
+            prompt: '',
+            workingDir: options.workingDir,
+            projectType: 'unknown',
+            projectName: path.basename(options.workingDir),
+            sources: [],
+            projectStructure: '',
+            mission: '',
+            status: 'idle'
+        };
+    }
+    /**
+     * Set LLM client for mission analysis
+     */
+    setLlmClient(client) {
+        this.llmClient = client;
+    }
+    /**
+     * Get current context
+     */
+    getContext() {
+        return { ...this.context };
+    }
+    /**
+     * Main entry point: execute a single prompt
+     */
+    async execute(prompt) {
+        this.context.prompt = prompt;
+        this.context.mission = prompt;
+        try {
+            // Phase 1: Detect project type
+            await this.detectProject();
+            // Phase 2: Scan sources
+            await this.scanProject();
+            // Phase 3: Analyze mission
+            await this.analyzeMission();
+            // Phase 4: Generate workflow
+            const workflow = await this.generateWorkflow();
+            this.updateStatus('ready');
+            return workflow;
+        }
+        catch (error) {
+            this.context.error = error instanceof Error ? error.message : 'Unknown error';
+            this.updateStatus('error');
+            throw error;
+        }
+    }
+    /**
+     * Quick execute without LLM analysis
+     */
+    async quickExecute(prompt) {
+        this.context.prompt = prompt;
+        this.context.mission = prompt;
+        try {
+            // Phase 1: Detect project type
+            await this.detectProject();
+            // Phase 2: Generate simple workflow
+            const workflow = (0, workflow_generator_1.createQuickWorkflow)(prompt, {
+                projectType: this.context.projectType,
+                projectName: this.context.projectName,
+                workingDir: this.context.workingDir
+            });
+            this.context.workflow = workflow;
+            this.updateStatus('ready');
+            return workflow;
+        }
+        catch (error) {
+            this.context.error = error instanceof Error ? error.message : 'Unknown error';
+            this.updateStatus('error');
+            throw error;
+        }
+    }
+    /**
+     * Phase 1: Detect project type
+     */
+    async detectProject() {
+        this.updateStatus('detecting');
+        this.emit('phase', 'detecting', 'Detecting project type...');
+        const detection = await (0, project_detector_1.detectProjectType)(this.context.workingDir);
+        this.context.projectType = detection.type;
+        this.context.projectName = detection.name;
+        if (this.options.verbose) {
+            console.log(`  Project: ${detection.name}`);
+            console.log(`  Type: ${detection.type} (${(detection.confidence * 100).toFixed(0)}% confidence)`);
+            console.log(`  Language: ${detection.mainLanguage || 'unknown'}`);
+        }
+    }
+    /**
+     * Phase 2: Scan sources
+     */
+    async scanProject() {
+        this.updateStatus('scanning');
+        this.emit('phase', 'scanning', 'Scanning source files...');
+        // Get project structure
+        this.context.projectStructure = (0, project_detector_1.getProjectStructure)(this.context.workingDir);
+        // Scan source files
+        this.context.sources = await (0, source_scanner_1.scanSources)(this.context.workingDir, this.context.projectType, { maxFiles: 50, maxFileSize: 100 * 1024 });
+        if (this.options.verbose) {
+            console.log(`  Found ${this.context.sources.length} relevant source files`);
+        }
+    }
+    /**
+     * Phase 3: Analyze mission
+     */
+    async analyzeMission() {
+        this.updateStatus('analyzing');
+        this.emit('phase', 'analyzing', 'Analyzing mission...');
+        const analyzerContext = {
+            projectType: this.context.projectType,
+            projectName: this.context.projectName,
+            projectStructure: this.context.projectStructure,
+            sources: this.context.sources,
+            keyFilesContent: (0, source_scanner_1.getKeyFilesContent)(this.context.sources)
+        };
+        if (this.llmClient) {
+            // Full LLM-powered analysis
+            this.context.analysis = await (0, mission_analyzer_1.analyzeMission)(this.context.prompt, analyzerContext, this.llmClient);
+        }
+        else {
+            // Quick heuristic analysis
+            this.context.analysis = (0, mission_analyzer_1.analyzeQuick)(this.context.prompt, analyzerContext);
+        }
+        if (this.options.verbose && this.context.analysis) {
+            console.log(`  Complexity: ${this.context.analysis.complexity}`);
+            console.log(`  Steps: ${this.context.analysis.steps.length}`);
+        }
+    }
+    /**
+     * Phase 4: Generate workflow
+     */
+    async generateWorkflow() {
+        this.updateStatus('generating');
+        this.emit('phase', 'generating', 'Generating workflow...');
+        if (!this.context.analysis) {
+            // Fallback: create simple workflow
+            return (0, workflow_generator_1.createQuickWorkflow)(this.context.prompt, {
+                projectType: this.context.projectType,
+                projectName: this.context.projectName,
+                workingDir: this.context.workingDir
+            });
+        }
+        const workflow = (0, workflow_generator_1.generateWorkflow)(this.context.analysis, {
+            projectType: this.context.projectType,
+            projectName: this.context.projectName,
+            workingDir: this.context.workingDir
+        });
+        this.context.workflow = workflow;
+        if (this.options.verbose) {
+            console.log(`  Workflow: ${workflow.name}`);
+            console.log(`  Agents: ${workflow.agents.length}`);
+            console.log(`  Steps: ${workflow.steps.length}`);
+        }
+        return workflow;
+    }
+    /**
+     * Convert to executable workflow format (compatible with existing ProjectManager)
+     */
+    toExecutableFormat() {
+        if (!this.context.workflow)
+            return null;
+        return (0, workflow_generator_1.toExecutableWorkflow)(this.context.workflow);
+    }
+    /**
+     * Convert to Speckit format (plan.md + tasks.md)
+     */
+    toSpeckit() {
+        return (0, speckit_generator_1.generateSpeckit)(this.context);
+    }
+    /**
+     * Generate and save Speckit files
+     */
+    saveSpeckit(outputDir) {
+        const speckit = this.toSpeckit();
+        if (outputDir) {
+            speckit.outputDir = outputDir;
+        }
+        return (0, speckit_generator_1.saveSpeckit)(speckit);
+    }
+    /**
+     * Update status and emit event
+     */
+    updateStatus(status, message) {
+        this.context.status = status;
+        this.emit('status', status, message);
+        if (this.options.verbose) {
+            console.log(`[AutoPilot] ${status}${message ? ': ' + message : ''}`);
+        }
+    }
+    /**
+     * Get a summary of the analysis for display
+     */
+    getSummary() {
+        const lines = [];
+        lines.push(`Project: ${this.context.projectName} (${this.context.projectType})`);
+        lines.push(`Mission: ${this.context.mission}`);
+        if (this.context.analysis) {
+            lines.push(`Complexity: ${this.context.analysis.complexity}`);
+            lines.push(`\nSteps:`);
+            for (let i = 0; i < this.context.analysis.steps.length; i++) {
+                const step = this.context.analysis.steps[i];
+                lines.push(`  ${i + 1}. ${step.name} [${step.type}]`);
+                if (step.dependsOn?.length) {
+                    lines.push(`     depends on: ${step.dependsOn.join(', ')}`);
+                }
+            }
+        }
+        if (this.context.workflow) {
+            lines.push(`\nWorkflow: ${this.context.workflow.name}`);
+            lines.push(`Agents:`);
+            for (const agent of this.context.workflow.agents) {
+                lines.push(`  - ${agent.name} (${agent.id})`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Save workflow to file
+     */
+    async saveWorkflow(outputPath) {
+        if (!this.context.workflow) {
+            throw new Error('No workflow generated yet');
+        }
+        const workflow = this.toExecutableFormat();
+        if (!workflow) {
+            throw new Error('Failed to convert workflow');
+        }
+        const filePath = outputPath || path.join(this.context.workingDir, '.sessioncast', 'workflows', `${workflow.name}.json`);
+        // Ensure directory exists
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, JSON.stringify(workflow, null, 2));
+        return filePath;
+    }
+}
+exports.AutoPilot = AutoPilot;
+/**
+ * Convenience function for one-shot execution
+ */
+async function autoPilot(prompt, options) {
+    const pilot = new AutoPilot(options);
+    return pilot.execute(prompt);
+}
+/**
+ * Quick version without LLM
+ */
+async function autoPilotQuick(prompt, options) {
+    const pilot = new AutoPilot(options);
+    return pilot.quickExecute(prompt);
+}

package/dist/autopilot/mission-analyzer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * MissionAnalyzer - LLM-based analysis of user prompts
+ * Breaks down a single prompt into structured workflow steps
+ */
+import { MissionAnalysis, ProjectType, SourceInfo } from './types';
+interface AnalyzerContext {
+    projectType: ProjectType;
+    projectName: string;
+    projectStructure: string;
+    sources: SourceInfo[];
+    keyFilesContent?: string;
+}
+interface LlmClient {
+    chat: (messages: {
+        role: string;
+        content: string;
+    }[]) => Promise<string>;
+}
+/**
+ * Analyze user prompt and generate mission breakdown
+ */
+export declare function analyzeMission(prompt: string, context: AnalyzerContext, llmClient: LlmClient): Promise<MissionAnalysis>;
+/**
+ * Analyze mission without LLM (for quick mode or when LLM is unavailable)
+ */
+export declare function analyzeQuick(prompt: string, context: AnalyzerContext): MissionAnalysis;
+export {};

package/dist/autopilot/mission-analyzer.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * MissionAnalyzer - LLM-based analysis of user prompts
+ * Breaks down a single prompt into structured workflow steps
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeMission = analyzeMission;
+exports.analyzeQuick = analyzeQuick;
+/**
+ * Analyze user prompt and generate mission breakdown
+ */
+async function analyzeMission(prompt, context, llmClient) {
+    const systemPrompt = buildSystemPrompt(context);
+    const userPrompt = buildUserPrompt(prompt, context);
+    try {
+        const response = await llmClient.chat([
+            { role: 'system', content: systemPrompt },
+            { role: 'user', content: userPrompt }
+        ]);
+        return parseAnalysisResponse(response, prompt);
+    }
+    catch (error) {
+        // Fallback to simple analysis if LLM fails
+        return createFallbackAnalysis(prompt, context);
+    }
+}
+/**
+ * Build system prompt for mission analysis
+ */
+function buildSystemPrompt(context) {
+    return `You are a software development task analyzer for SessionCast.
+Your job is to analyze user requests and break them down into executable steps.
+
+Project Information:
+- Type: ${context.projectType}
+- Name: ${context.projectName}
+- Main Language: ${getMainLanguage(context.projectType)}
+
+Rules:
+1. Break down the task into clear, independent steps
+2. Each step should be achievable by a single AI agent
+3. Consider dependencies between steps
+4. Estimate complexity based on the scope of changes
+5. Identify required agent types: frontend, backend, fullstack, mobile, infra, test
+
+Response Format (JSON):
+{
+  "mission": "Brief summary of the mission",
+  "complexity": "simple|medium|complex",
+  "steps": [
+    {
+      "name": "Step name",
+      "description": "What this step accomplishes",
+      "type": "frontend|backend|fullstack|mobile|infra|test",
+      "prompt": "Detailed prompt for the AI agent",
+      "dependsOn": ["previous step names if any"]
+    }
+  ],
+  "requiredAgents": ["agent types needed"],
+  "estimatedFiles": ["likely files to be modified"]
+}`;
+}
+/**
+ * Build user prompt with context
+ */
+function buildUserPrompt(prompt, context) {
+    let userContent = `Analyze this task and break it down into executable steps:
+
+USER REQUEST: ${prompt}
+
+PROJECT STRUCTURE:
+${context.projectStructure}
+
+SOURCE FILES:
+${context.sources.map(s => `- ${s.relativePath} (${s.type})`).join('\n')}`;
+    if (context.keyFilesContent) {
+        userContent += `\n\nKEY FILES CONTENT:\n${context.keyFilesContent}`;
+    }
+    return userContent;
+}
+/**
+ * Parse LLM response into MissionAnalysis
+ */
+function parseAnalysisResponse(response, originalPrompt) {
+    try {
+        // Extract JSON from response
+        const jsonMatch = response.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            throw new Error('No JSON found in response');
+        }
+        const parsed = JSON.parse(jsonMatch[0]);
+        // Validate and normalize
+        const analysis = {
+            mission: parsed.mission || originalPrompt,
+            complexity: validateComplexity(parsed.complexity),
+            steps: normalizeSteps(parsed.steps || []),
+            requiredAgents: parsed.requiredAgents || [],
+            estimatedFiles: parsed.estimatedFiles || []
+        };
+        // Ensure at least one step
+        if (analysis.steps.length === 0) {
+            analysis.steps = [{
+                    name: 'Execute task',
+                    description: originalPrompt,
+                    type: 'fullstack',
+                    prompt: originalPrompt
+                }];
+        }
+        return analysis;
+    }
+    catch (error) {
+        // Return basic analysis if parsing fails
+        return {
+            mission: originalPrompt,
+            complexity: 'simple',
+            steps: [{
+                    name: 'Execute task',
+                    description: originalPrompt,
+                    type: 'fullstack',
+                    prompt: originalPrompt
+                }],
+            requiredAgents: ['fullstack'],
+            estimatedFiles: []
+        };
+    }
+}
+/**
+ * Validate complexity value
+ */
+function validateComplexity(value) {
+    const valid = ['simple', 'medium', 'complex'];
+    return valid.includes(value) ? value : 'simple';
+}
+/**
+ * Normalize steps array
+ */
+function normalizeSteps(steps) {
+    return steps.map((step, index) => ({
+        name: step.name || `Step ${index + 1}`,
+        description: step.description || '',
+        type: validateStepType(step.type),
+        prompt: step.prompt || step.description || '',
+        dependsOn: Array.isArray(step.dependsOn) ? step.dependsOn : undefined
+    }));
+}
+/**
+ * Validate step type
+ */
+function validateStepType(value) {
+    const valid = ['frontend', 'backend', 'fullstack', 'mobile', 'infra', 'test'];
+    return valid.includes(value) ? value : 'fullstack';
+}
+/**
+ * Get main language for project type
+ */
+function getMainLanguage(projectType) {
+    const map = {
+        android: 'Kotlin/Java',
+        ios: 'Swift',
+        react: 'TypeScript/React',
+        next: 'TypeScript/Next.js',
+        vue: 'TypeScript/Vue',
+        node: 'JavaScript/Node.js',
+        python: 'Python',
+        spring: 'Java/Spring',
+        go: 'Go',
+        rust: 'Rust',
+        unknown: 'Unknown'
+    };
+    return map[projectType];
+}
+/**
+ * Create fallback analysis without LLM
+ */
+function createFallbackAnalysis(prompt, context) {
+    // Simple heuristic-based analysis
+    const promptLower = prompt.toLowerCase();
+    let type = 'fullstack';
+    let complexity = 'simple';
+    // Detect type from keywords
+    if (promptLower.includes('ui') || promptLower.includes('화면') || promptLower.includes('button') || promptLower.includes('버튼')) {
+        type = 'frontend';
+    }
+    else if (promptLower.includes('api') || promptLower.includes('database') || promptLower.includes('db') || promptLower.includes('서버')) {
+        type = 'backend';
+    }
+    else if (promptLower.includes('test') || promptLower.includes('테스트')) {
+        type = 'test';
+    }
+    else if (promptLower.includes('deploy') || promptLower.includes('docker') || promptLower.includes('배포')) {
+        type = 'infra';
+    }
+    // Mobile detection based on project type
+    if (context.projectType === 'android' || context.projectType === 'ios') {
+        type = 'mobile';
+    }
+    // Detect complexity from keywords
+    if (promptLower.includes('refactor') ||
+        promptLower.includes('리팩토링') ||
+        promptLower.includes('architecture') ||
+        promptLower.includes('아키텍처') ||
+        promptLower.includes('전체') ||
+        promptLower.includes('모든')) {
+        complexity = 'complex';
+    }
+    else if (promptLower.includes('add') ||
+        promptLower.includes('추가') ||
+        promptLower.includes('create') ||
+        promptLower.includes('생성') ||
+        promptLower.includes('implement') ||
+        promptLower.includes('구현')) {
+        complexity = 'medium';
+    }
+    return {
+        mission: prompt,
+        complexity,
+        steps: [{
+                name: 'Execute task',
+                description: prompt,
+                type,
+                prompt
+            }],
+        requiredAgents: [type === 'mobile' ? 'mobile' : type],
+        estimatedFiles: []
+    };
+}
+/**
+ * Analyze mission without LLM (for quick mode or when LLM is unavailable)
+ */
+function analyzeQuick(prompt, context) {
+    return createFallbackAnalysis(prompt, context);
+}

package/dist/autopilot/project-detector.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ProjectDetector - Auto-detect project type from directory
+ */
+import { ProjectDetectionResult } from './types';
+/**
+ * Detect project type from directory
+ */
+export declare function detectProjectType(dir: string): Promise<ProjectDetectionResult>;
+/**
+ * Get a summary of project structure for LLM context
+ */
+export declare function getProjectStructure(dir: string, maxDepth?: number): string;