sessioncast-cli 2.0.2 → 2.0.3

package/dist/autopilot/mission-analyzer.js

@@ -1,232 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-/**
- * 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;

package/dist/autopilot/project-detector.js

@@ -1,326 +0,0 @@
-"use strict";
-/**
- * ProjectDetector - Auto-detect project type from directory
- */
-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.detectProjectType = detectProjectType;
-exports.getProjectStructure = getProjectStructure;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const PROJECT_SIGNATURES = {
-    android: {
-        files: ['build.gradle', 'app/build.gradle', 'settings.gradle'],
-        contentPatterns: [
-            { file: 'build.gradle', pattern: /android\s*\{/ },
-            { file: 'app/build.gradle', pattern: /android\s*\{/ }
-        ],
-        weight: 10
-    },
-    ios: {
-        files: ['*.xcodeproj', '*.xcworkspace', 'Podfile', 'Package.swift'],
-        weight: 10
-    },
-    react: {
-        files: ['package.json'],
-        contentPatterns: [
-            { file: 'package.json', pattern: /"react":\s*"/ }
-        ],
-        weight: 8
-    },
-    next: {
-        files: ['next.config.js', 'next.config.mjs', 'next.config.ts'],
-        weight: 9
-    },
-    vue: {
-        files: ['vue.config.js', 'vite.config.ts', 'vite.config.js'],
-        contentPatterns: [
-            { file: 'package.json', pattern: /"vue":\s*"/ }
-        ],
-        weight: 8
-    },
-    node: {
-        files: ['package.json'],
-        weight: 5
-    },
-    python: {
-        files: ['requirements.txt', 'pyproject.toml', 'setup.py', 'Pipfile'],
-        weight: 7
-    },
-    spring: {
-        files: ['pom.xml', 'build.gradle'],
-        contentPatterns: [
-            { file: 'pom.xml', pattern: /spring-boot/ },
-            { file: 'build.gradle', pattern: /spring-boot/ }
-        ],
-        weight: 9
-    },
-    go: {
-        files: ['go.mod', 'go.sum'],
-        weight: 8
-    },
-    rust: {
-        files: ['Cargo.toml', 'Cargo.lock'],
-        weight: 8
-    },
-    unknown: {
-        files: [],
-        weight: 0
-    }
-};
-const LANGUAGE_MAP = {
-    android: 'kotlin',
-    ios: 'swift',
-    react: 'typescript',
-    next: 'typescript',
-    vue: 'typescript',
-    node: 'javascript',
-    python: 'python',
-    spring: 'java',
-    go: 'go',
-    rust: 'rust'
-};
-/**
- * Detect project type from directory
- */
-async function detectProjectType(dir) {
-    const scores = new Map();
-    const foundConfigFiles = [];
-    // Initialize scores
-    for (const type of Object.keys(PROJECT_SIGNATURES)) {
-        scores.set(type, 0);
-    }
-    // Check file signatures
-    for (const [type, signature] of Object.entries(PROJECT_SIGNATURES)) {
-        for (const filePattern of signature.files) {
-            const found = await findFiles(dir, filePattern);
-            if (found.length > 0) {
-                scores.set(type, (scores.get(type) || 0) + signature.weight);
-                foundConfigFiles.push(...found);
-            }
-        }
-        // Check content patterns
-        if (signature.contentPatterns) {
-            for (const { file, pattern } of signature.contentPatterns) {
-                const filePath = path.join(dir, file);
-                if (fs.existsSync(filePath)) {
-                    try {
-                        const content = fs.readFileSync(filePath, 'utf-8');
-                        if (pattern.test(content)) {
-                            scores.set(type, (scores.get(type) || 0) + 5);
-                        }
-                    }
-                    catch {
-                        // Ignore read errors
-                    }
-                }
-            }
-        }
-    }
-    // Find the best match
-    let bestType = 'unknown';
-    let bestScore = 0;
-    let totalScore = 0;
-    for (const [type, score] of scores.entries()) {
-        totalScore += score;
-        if (score > bestScore) {
-            bestScore = score;
-            bestType = type;
-        }
-    }
-    // Calculate confidence
-    const confidence = totalScore > 0 ? Math.min(bestScore / (totalScore * 0.5), 1) : 0;
-    // Get project name
-    const projectName = await getProjectName(dir, bestType);
-    return {
-        type: bestType,
-        name: projectName,
-        confidence,
-        configFiles: [...new Set(foundConfigFiles)],
-        mainLanguage: LANGUAGE_MAP[bestType]
-    };
-}
-/**
- * Find files matching pattern in directory
- */
-async function findFiles(dir, pattern) {
-    const results = [];
-    try {
-        if (pattern.includes('*')) {
-            // Glob pattern
-            const ext = pattern.replace('*', '');
-            const entries = fs.readdirSync(dir);
-            for (const entry of entries) {
-                if (entry.endsWith(ext)) {
-                    results.push(entry);
-                }
-            }
-        }
-        else if (pattern.includes('/')) {
-            // Path pattern
-            const fullPath = path.join(dir, pattern);
-            if (fs.existsSync(fullPath)) {
-                results.push(pattern);
-            }
-        }
-        else {
-            // Simple filename
-            const fullPath = path.join(dir, pattern);
-            if (fs.existsSync(fullPath)) {
-                results.push(pattern);
-            }
-        }
-    }
-    catch {
-        // Ignore errors
-    }
-    return results;
-}
-/**
- * Get project name from config files
- */
-async function getProjectName(dir, type) {
-    // Try package.json
-    const packageJsonPath = path.join(dir, 'package.json');
-    if (fs.existsSync(packageJsonPath)) {
-        try {
-            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-            if (pkg.name)
-                return pkg.name;
-        }
-        catch {
-            // Ignore
-        }
-    }
-    // Try settings.gradle (Android)
-    const settingsGradlePath = path.join(dir, 'settings.gradle');
-    if (fs.existsSync(settingsGradlePath)) {
-        try {
-            const content = fs.readFileSync(settingsGradlePath, 'utf-8');
-            const match = content.match(/rootProject\.name\s*=\s*['"](.+)['"]/);
-            if (match)
-                return match[1];
-        }
-        catch {
-            // Ignore
-        }
-    }
-    // Try pom.xml (Maven)
-    const pomPath = path.join(dir, 'pom.xml');
-    if (fs.existsSync(pomPath)) {
-        try {
-            const content = fs.readFileSync(pomPath, 'utf-8');
-            const match = content.match(/<artifactId>(.+?)<\/artifactId>/);
-            if (match)
-                return match[1];
-        }
-        catch {
-            // Ignore
-        }
-    }
-    // Try Cargo.toml (Rust)
-    const cargoPath = path.join(dir, 'Cargo.toml');
-    if (fs.existsSync(cargoPath)) {
-        try {
-            const content = fs.readFileSync(cargoPath, 'utf-8');
-            const match = content.match(/name\s*=\s*"(.+?)"/);
-            if (match)
-                return match[1];
-        }
-        catch {
-            // Ignore
-        }
-    }
-    // Try go.mod (Go)
-    const goModPath = path.join(dir, 'go.mod');
-    if (fs.existsSync(goModPath)) {
-        try {
-            const content = fs.readFileSync(goModPath, 'utf-8');
-            const match = content.match(/module\s+(.+)/);
-            if (match) {
-                const parts = match[1].split('/');
-                return parts[parts.length - 1];
-            }
-        }
-        catch {
-            // Ignore
-        }
-    }
-    // Fallback to directory name
-    return path.basename(dir);
-}
-/**
- * Get a summary of project structure for LLM context
- */
-function getProjectStructure(dir, maxDepth = 3) {
-    const lines = [];
-    function walk(currentDir, prefix, depth) {
-        if (depth > maxDepth)
-            return;
-        try {
-            const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-            // Sort: directories first, then files
-            entries.sort((a, b) => {
-                if (a.isDirectory() && !b.isDirectory())
-                    return -1;
-                if (!a.isDirectory() && b.isDirectory())
-                    return 1;
-                return a.name.localeCompare(b.name);
-            });
-            // Filter out common non-essential directories
-            const filtered = entries.filter(e => !['node_modules', '.git', '.gradle', 'build', 'dist', '__pycache__',
-                '.idea', '.vscode', 'target', '.next', 'venv', 'env'].includes(e.name));
-            for (let i = 0; i < filtered.length; i++) {
-                const entry = filtered[i];
-                const isLast = i === filtered.length - 1;
-                const connector = isLast ? '└── ' : '├── ';
-                const newPrefix = prefix + (isLast ? '    ' : '│   ');
-                if (entry.isDirectory()) {
-                    lines.push(`${prefix}${connector}${entry.name}/`);
-                    walk(path.join(currentDir, entry.name), newPrefix, depth + 1);
-                }
-                else {
-                    lines.push(`${prefix}${connector}${entry.name}`);
-                }
-            }
-        }
-        catch {
-            // Ignore permission errors
-        }
-    }
-    lines.push(path.basename(dir) + '/');
-    walk(dir, '', 1);
-    return lines.slice(0, 100).join('\n'); // Limit to 100 lines
-}

package/dist/autopilot/source-scanner.d.ts

@@ -1,26 +0,0 @@
-/**
- * SourceScanner - Scan and collect relevant source files for context
- */
-import { SourceInfo, ProjectType } from './types';
-interface ScanOptions {
-    maxFiles?: number;
-    maxFileSize?: number;
-    includeTests?: boolean;
-}
-/**
- * Scan directory for source files
- */
-export declare function scanSources(dir: string, projectType: ProjectType, options?: ScanOptions): Promise<SourceInfo[]>;
-/**
- * Read source file content (for LLM context)
- */
-export declare function readSourceContent(source: SourceInfo): string | null;
-/**
- * Get condensed context for LLM (file list with sizes)
- */
-export declare function getSourcesSummary(sources: SourceInfo[]): string;
-/**
- * Get key files content for deep analysis
- */
-export declare function getKeyFilesContent(sources: SourceInfo[], maxTotalSize?: number): string;
-export {};