sessioncast-cli 2.0.0 → 2.0.2

package/dist/autopilot/speckit-generator.js

@@ -0,0 +1,511 @@
+"use strict";
+/**
+ * Speckit Generator - Convert AutoPilot workflow to Speckit format
+ *
+ * Speckit is a structured markdown format for development plans:
+ * - plan.md: Technical context, goals, architecture decisions
+ * - tasks.md: Step-by-step task list with T-x.y IDs, dependencies, validation
+ *
+ * Reference: https://github.com/devload/claude-planflow-skills
+ */
+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.generateSpeckit = generateSpeckit;
+exports.saveSpeckit = saveSpeckit;
+exports.generateQuickSpeckit = generateQuickSpeckit;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Generate Speckit files from AutoPilot context
+ */
+function generateSpeckit(context) {
+    const featureName = sanitizeFeatureName(context.mission);
+    const timestamp = formatDate(new Date());
+    // Convert workflow steps to Speckit tasks
+    const phases = convertToPhases(context);
+    // Generate plan.md
+    const planMd = generatePlanMd({
+        featureName,
+        timestamp,
+        mission: context.mission,
+        projectType: context.projectType,
+        projectName: context.projectName,
+        projectStructure: context.projectStructure,
+        analysis: context.analysis,
+        workflow: context.workflow
+    });
+    // Generate tasks.md
+    const tasksMd = generateTasksMd({
+        featureName,
+        timestamp,
+        phases,
+        workflow: context.workflow
+    });
+    const outputDir = path.join(context.workingDir, '.sessioncast', 'specs', featureName);
+    return {
+        featureName,
+        planMd,
+        tasksMd,
+        outputDir
+    };
+}
+/**
+ * Save Speckit files to disk
+ */
+function saveSpeckit(speckit) {
+    // Ensure directory exists
+    if (!fs.existsSync(speckit.outputDir)) {
+        fs.mkdirSync(speckit.outputDir, { recursive: true });
+    }
+    const planPath = path.join(speckit.outputDir, 'plan.md');
+    const tasksPath = path.join(speckit.outputDir, 'tasks.md');
+    fs.writeFileSync(planPath, speckit.planMd, 'utf-8');
+    fs.writeFileSync(tasksPath, speckit.tasksMd, 'utf-8');
+    return { planPath, tasksPath };
+}
+/**
+ * Convert workflow steps to Speckit phases
+ */
+function convertToPhases(context) {
+    const workflow = context.workflow;
+    const analysis = context.analysis;
+    if (!workflow) {
+        // No workflow, create single phase with mission
+        return [{
+                number: 1,
+                name: 'Implementation',
+                tasks: [{
+                        id: 'T-1.1',
+                        phase: 1,
+                        sequence: 1,
+                        title: 'Execute mission',
+                        description: context.mission,
+                        files: [],
+                        dependencies: [],
+                        validation: 'Task completed successfully',
+                        parallel: false
+                    }]
+            }];
+    }
+    // Group steps by type for phase organization
+    const phases = [];
+    const stepsByPhase = groupStepsByPhase(workflow.steps, analysis);
+    let phaseNumber = 1;
+    for (const [phaseName, steps] of stepsByPhase) {
+        const tasks = [];
+        let sequence = 1;
+        for (const step of steps) {
+            const taskId = `T-${phaseNumber}.${sequence}`;
+            // Determine if task can run in parallel
+            const canParallel = canRunInParallel(step, steps);
+            // Convert dependencies to task IDs
+            const deps = convertDependencies(step.dependsOn || [], workflow.steps, stepsByPhase);
+            // Infer files from step description/name
+            const files = inferFiles(step, context);
+            // Generate validation criteria
+            const validation = generateValidation(step, context);
+            tasks.push({
+                id: taskId,
+                phase: phaseNumber,
+                sequence,
+                title: step.name,
+                description: step.description || step.prompt,
+                files,
+                dependencies: deps,
+                validation,
+                parallel: canParallel
+            });
+            sequence++;
+        }
+        phases.push({
+            number: phaseNumber,
+            name: phaseName,
+            tasks
+        });
+        phaseNumber++;
+    }
+    return phases;
+}
+/**
+ * Group workflow steps into logical phases
+ */
+function groupStepsByPhase(steps, analysis) {
+    const phases = new Map();
+    if (steps.length === 1) {
+        // Single step = single phase
+        phases.set('Implementation', steps);
+        return phases;
+    }
+    // Try to group by step type or dependencies
+    // Phase 1: Setup/Foundation (no dependencies)
+    // Phase 2: Core Implementation (has dependencies)
+    // Phase 3: Testing/Integration (test-related)
+    const setup = [];
+    const core = [];
+    const testing = [];
+    for (const step of steps) {
+        const lowerName = step.name.toLowerCase();
+        const lowerDesc = (step.description || '').toLowerCase();
+        if (lowerName.includes('test') || lowerDesc.includes('test')) {
+            testing.push(step);
+        }
+        else if (!step.dependsOn || step.dependsOn.length === 0) {
+            setup.push(step);
+        }
+        else {
+            core.push(step);
+        }
+    }
+    if (setup.length > 0)
+        phases.set('Setup', setup);
+    if (core.length > 0)
+        phases.set('Core Implementation', core);
+    if (testing.length > 0)
+        phases.set('Testing & Validation', testing);
+    // If all in one phase, use generic name
+    if (phases.size === 0) {
+        phases.set('Implementation', steps);
+    }
+    return phases;
+}
+/**
+ * Check if a step can run in parallel with others in same phase
+ */
+function canRunInParallel(step, phaseSteps) {
+    // If no dependencies within this phase, can potentially run in parallel
+    if (!step.dependsOn || step.dependsOn.length === 0) {
+        // Check if other steps depend on this one
+        const dependents = phaseSteps.filter(s => s.dependsOn?.includes(step.id));
+        return dependents.length === 0;
+    }
+    return false;
+}
+/**
+ * Convert step-id dependencies to T-x.y format
+ */
+function convertDependencies(deps, allSteps, stepsByPhase) {
+    const result = [];
+    for (const depId of deps) {
+        const depStep = allSteps.find(s => s.id === depId);
+        if (!depStep)
+            continue;
+        // Find which phase this dependency is in
+        let phaseNum = 1;
+        let seqNum = 1;
+        for (const [phaseName, phaseSteps] of stepsByPhase) {
+            const idx = phaseSteps.findIndex(s => s.id === depId);
+            if (idx !== -1) {
+                seqNum = idx + 1;
+                break;
+            }
+            phaseNum++;
+        }
+        result.push(`T-${phaseNum}.${seqNum}`);
+    }
+    return result;
+}
+/**
+ * Infer affected files from step
+ */
+function inferFiles(step, context) {
+    const files = [];
+    const text = `${step.name} ${step.description || ''} ${step.prompt}`.toLowerCase();
+    // Common patterns
+    const patterns = [
+        { regex: /\.tsx?\b/g, ext: '.ts' },
+        { regex: /\.jsx?\b/g, ext: '.js' },
+        { regex: /component/g, ext: '.tsx' },
+        { regex: /service/g, ext: '.ts' },
+        { regex: /test/g, ext: '.test.ts' },
+        { regex: /api|endpoint|route/g, ext: '.ts' },
+        { regex: /schema|model/g, ext: '.prisma' },
+        { regex: /config/g, ext: '.json' },
+    ];
+    // Check project sources for matches
+    const sources = context.sources || [];
+    for (const source of sources) {
+        const relPath = source.relativePath.toLowerCase();
+        if (text.includes(path.basename(relPath, path.extname(relPath)))) {
+            files.push(source.relativePath);
+        }
+    }
+    // Limit to 3 files
+    return files.slice(0, 3);
+}
+/**
+ * Generate validation criteria for a step
+ */
+function generateValidation(step, context) {
+    const lowerName = step.name.toLowerCase();
+    const lowerDesc = (step.description || '').toLowerCase();
+    // Common validation patterns
+    if (lowerName.includes('test') || lowerDesc.includes('test')) {
+        return 'All tests pass (`npm test` or equivalent)';
+    }
+    if (lowerName.includes('build') || lowerDesc.includes('compile')) {
+        return 'Build completes without errors';
+    }
+    if (lowerName.includes('setup') || lowerName.includes('init')) {
+        return 'Dependencies installed and configuration files created';
+    }
+    if (lowerName.includes('api') || lowerDesc.includes('endpoint')) {
+        return 'API endpoint responds correctly (manual or automated verification)';
+    }
+    if (lowerName.includes('ui') || lowerName.includes('component')) {
+        return 'Component renders correctly without console errors';
+    }
+    // Default
+    return 'Implementation complete and functioning as expected';
+}
+/**
+ * Generate plan.md content
+ */
+function generatePlanMd(params) {
+    const { featureName, timestamp, mission, projectType, projectName, projectStructure, analysis, workflow } = params;
+    const lines = [];
+    // Header
+    lines.push(`# Plan: ${featureName}`);
+    lines.push('');
+    lines.push(`- **Branch**: feature/${featureName}`);
+    lines.push(`- **Date**: ${timestamp}`);
+    lines.push(`- **Spec**: specs/${featureName}/tasks.md`);
+    lines.push('');
+    // Summary
+    lines.push('## Summary');
+    lines.push('');
+    lines.push(mission);
+    lines.push('');
+    // Technical Context
+    lines.push('## Technical Context');
+    lines.push('');
+    lines.push('| Aspect | Value |');
+    lines.push('|--------|-------|');
+    lines.push(`| Project Type | ${projectType} |`);
+    lines.push(`| Project Name | ${projectName} |`);
+    if (analysis) {
+        lines.push(`| Complexity | ${analysis.complexity} |`);
+        lines.push(`| Estimated Steps | ${analysis.steps.length} |`);
+    }
+    if (workflow) {
+        lines.push(`| Agents | ${workflow.agents.length} |`);
+    }
+    lines.push('');
+    // Project Structure (if available)
+    if (projectStructure) {
+        lines.push('## Project Structure');
+        lines.push('');
+        lines.push('```');
+        // Limit to first 20 lines
+        const structLines = projectStructure.split('\n').slice(0, 20);
+        lines.push(structLines.join('\n'));
+        if (projectStructure.split('\n').length > 20) {
+            lines.push('...');
+        }
+        lines.push('```');
+        lines.push('');
+    }
+    // Architecture Notes
+    lines.push('## Architecture Notes');
+    lines.push('');
+    if (workflow && workflow.agents.length > 0) {
+        lines.push('### Agents');
+        lines.push('');
+        for (const agent of workflow.agents) {
+            lines.push(`- **${agent.name}** (${agent.id})`);
+            lines.push(`  - Role: ${agent.role}`);
+            lines.push(`  - Working Dir: ${agent.workingDir}`);
+        }
+        lines.push('');
+    }
+    if (analysis && analysis.steps.length > 0) {
+        lines.push('### Implementation Approach');
+        lines.push('');
+        for (let i = 0; i < analysis.steps.length && i < 5; i++) {
+            const step = analysis.steps[i];
+            lines.push(`${i + 1}. **${step.name}**: ${step.description}`);
+        }
+        if (analysis.steps.length > 5) {
+            lines.push(`... and ${analysis.steps.length - 5} more steps`);
+        }
+        lines.push('');
+    }
+    // Notes section
+    lines.push('## Notes');
+    lines.push('');
+    lines.push('- Generated by SessionCast AutoPilot');
+    lines.push(`- Workflow: ${workflow?.name || 'N/A'}`);
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Generate tasks.md content
+ */
+function generateTasksMd(params) {
+    const { featureName, timestamp, phases, workflow } = params;
+    const lines = [];
+    // Header
+    lines.push(`# Tasks: ${featureName}`);
+    lines.push('');
+    lines.push(`Generated by: SessionCast AutoPilot`);
+    lines.push(`Date: ${timestamp}`);
+    lines.push(`Workflow: ${workflow?.name || 'quick'}`);
+    lines.push('');
+    // Phases and Tasks
+    for (const phase of phases) {
+        lines.push(`## Phase ${phase.number}: ${phase.name}`);
+        lines.push('');
+        for (const task of phase.tasks) {
+            // Task header with optional [P] marker
+            const parallelMarker = task.parallel ? ' [P]' : '';
+            lines.push(`### ${task.id}: ${task.title}${parallelMarker}`);
+            lines.push('');
+            lines.push(`- **Description**: ${task.description}`);
+            if (task.files.length > 0) {
+                lines.push(`- **Files**: ${task.files.map(f => `\`${f}\``).join(', ')}`);
+            }
+            else {
+                lines.push('- **Files**: (to be determined)');
+            }
+            if (task.dependencies.length > 0) {
+                lines.push(`- **Dependencies**: ${task.dependencies.join(', ')}`);
+            }
+            else {
+                lines.push('- **Dependencies**: None');
+            }
+            lines.push(`- **Validation**: ${task.validation}`);
+            lines.push('');
+        }
+        lines.push('---');
+        lines.push('');
+    }
+    // Checklist
+    lines.push('## Checklist');
+    lines.push('');
+    for (const phase of phases) {
+        for (const task of phase.tasks) {
+            lines.push(`- [ ] ${task.id}: ${task.title}`);
+        }
+    }
+    lines.push('');
+    // Notes
+    lines.push('## Notes');
+    lines.push('');
+    lines.push('- Tasks marked with `[P]` can run in parallel when dependencies allow');
+    lines.push('- Update checklist as tasks are completed');
+    lines.push('- Use `git commit` after completing each phase');
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Sanitize feature name for directory/file names
+ */
+function sanitizeFeatureName(mission) {
+    return mission
+        .toLowerCase()
+        .replace(/[^a-z0-9가-힣\s-]/g, '') // Keep Korean characters
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .substring(0, 50); // Limit length
+}
+/**
+ * Format date as YYYY-MM-DD
+ */
+function formatDate(date) {
+    return date.toISOString().split('T')[0];
+}
+/**
+ * Quick Speckit generation from just a prompt (without full analysis)
+ */
+function generateQuickSpeckit(prompt, context) {
+    const featureName = sanitizeFeatureName(prompt);
+    const timestamp = formatDate(new Date());
+    const planMd = `# Plan: ${featureName}
+
+- **Branch**: feature/${featureName}
+- **Date**: ${timestamp}
+- **Spec**: specs/${featureName}/tasks.md
+
+## Summary
+
+${prompt}
+
+## Technical Context
+
+| Aspect | Value |
+|--------|-------|
+| Project Type | ${context.projectType} |
+| Project Name | ${context.projectName} |
+
+## Architecture Notes
+
+Single-agent quick execution workflow.
+
+## Notes
+
+- Generated by SessionCast AutoPilot (Quick Mode)
+`;
+    const tasksMd = `# Tasks: ${featureName}
+
+Generated by: SessionCast AutoPilot (Quick Mode)
+Date: ${timestamp}
+
+## Phase 1: Implementation
+
+### T-1.1: Execute mission
+- **Description**: ${prompt}
+- **Files**: (to be determined during implementation)
+- **Dependencies**: None
+- **Validation**: Implementation complete and functioning as expected
+
+---
+
+## Checklist
+
+- [ ] T-1.1: Execute mission
+
+## Notes
+
+- Quick mode generates a single-task workflow
+- For detailed task breakdown, use full analysis mode
+`;
+    const outputDir = path.join(context.workingDir, '.sessioncast', 'specs', featureName);
+    return {
+        featureName,
+        planMd,
+        tasksMd,
+        outputDir
+    };
+}

package/dist/autopilot/types.d.ts

@@ -0,0 +1,110 @@
+/**
+ * AutoPilot Types
+ * Single-prompt execution layer for SessionCast
+ */
+export type ProjectType = 'android' | 'ios' | 'react' | 'next' | 'vue' | 'node' | 'python' | 'spring' | 'go' | 'rust' | 'unknown';
+export type StepType = 'frontend' | 'backend' | 'fullstack' | 'mobile' | 'infra' | 'test';
+export type Complexity = 'simple' | 'medium' | 'complex';
+export interface SourceInfo {
+    path: string;
+    relativePath: string;
+    type: 'code' | 'config' | 'doc' | 'test';
+    language?: string;
+    size: number;
+}
+export interface ProjectDetectionResult {
+    type: ProjectType;
+    name: string;
+    confidence: number;
+    configFiles: string[];
+    mainLanguage?: string;
+}
+export interface MissionAnalysis {
+    mission: string;
+    complexity: Complexity;
+    steps: AnalyzedStep[];
+    requiredAgents: string[];
+    estimatedFiles: string[];
+}
+export interface AnalyzedStep {
+    name: string;
+    description: string;
+    type: StepType;
+    prompt: string;
+    dependsOn?: string[];
+}
+export interface WorkflowStep {
+    id: string;
+    name: string;
+    description: string;
+    agentId: string;
+    prompt: string;
+    dependsOn?: string[];
+    status?: 'pending' | 'running' | 'completed' | 'error';
+}
+export interface AgentConfig {
+    id: string;
+    name: string;
+    role: string;
+    workingDir: string;
+}
+export interface GeneratedWorkflow {
+    name: string;
+    mission: string;
+    agents: AgentConfig[];
+    steps: WorkflowStep[];
+}
+export interface AutoPilotContext {
+    prompt: string;
+    workingDir: string;
+    projectType: ProjectType;
+    projectName: string;
+    sources: SourceInfo[];
+    projectStructure: string;
+    mission: string;
+    analysis?: MissionAnalysis;
+    workflow?: GeneratedWorkflow;
+    status: AutoPilotStatus;
+    error?: string;
+}
+export type AutoPilotStatus = 'idle' | 'detecting' | 'scanning' | 'analyzing' | 'generating' | 'ready' | 'running' | 'completed' | 'error';
+export interface AutoPilotOptions {
+    workingDir: string;
+    relayUrl?: string;
+    token?: string;
+    verbose?: boolean;
+    dryRun?: boolean;
+    skipConfirm?: boolean;
+}
+export interface AutoPilotEvents {
+    onStatusChange?: (status: AutoPilotStatus, message?: string) => void;
+    onStepStart?: (step: WorkflowStep) => void;
+    onStepComplete?: (step: WorkflowStep) => void;
+    onError?: (error: Error) => void;
+}
+/**
+ * Speckit Types
+ * Structured markdown format for development plans
+ */
+export interface SpeckitTask {
+    id: string;
+    phase: number;
+    sequence: number;
+    title: string;
+    description: string;
+    files: string[];
+    dependencies: string[];
+    validation: string;
+    parallel: boolean;
+}
+export interface SpeckitPhase {
+    number: number;
+    name: string;
+    tasks: SpeckitTask[];
+}
+export interface SpeckitOutput {
+    featureName: string;
+    planMd: string;
+    tasksMd: string;
+    outputDir: string;
+}

package/dist/autopilot/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * AutoPilot Types
+ * Single-prompt execution layer for SessionCast
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/autopilot/workflow-generator.d.ts

@@ -0,0 +1,33 @@
+/**
+ * WorkflowGenerator - Convert mission analysis into executable workflow
+ */
+import { MissionAnalysis, ProjectType, GeneratedWorkflow } from './types';
+interface GeneratorContext {
+    projectType: ProjectType;
+    projectName: string;
+    workingDir: string;
+}
+/**
+ * Generate workflow from mission analysis
+ */
+export declare function generateWorkflow(analysis: MissionAnalysis, context: GeneratorContext): GeneratedWorkflow;
+/**
+ * Convert GeneratedWorkflow to existing Workflow format
+ */
+export declare function toExecutableWorkflow(generated: GeneratedWorkflow): {
+    name: string;
+    mission: string;
+    created: string;
+    agents: Array<{
+        id: string;
+        name: string;
+        workDir: string;
+        tasks: string[];
+        dependsOn: string[];
+    }>;
+};
+/**
+ * Create a simple single-agent workflow for quick execution
+ */
+export declare function createQuickWorkflow(prompt: string, context: GeneratorContext): GeneratedWorkflow;
+export {};