sessioncast-cli 2.0.0 → 2.0.2

package/dist/autopilot/project-detector.js

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

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

package/dist/autopilot/source-scanner.js

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * SourceScanner - Scan and collect relevant source files for context
+ */
+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.scanSources = scanSources;
+exports.readSourceContent = readSourceContent;
+exports.getSourcesSummary = getSourcesSummary;
+exports.getKeyFilesContent = getKeyFilesContent;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const DEFAULT_OPTIONS = {
+    maxFiles: 50,
+    maxFileSize: 100 * 1024, // 100KB
+    includeTests: false
+};
+// File extensions by project type
+const LANGUAGE_EXTENSIONS = {
+    kotlin: ['.kt', '.kts'],
+    java: ['.java'],
+    swift: ['.swift'],
+    typescript: ['.ts', '.tsx'],
+    javascript: ['.js', '.jsx'],
+    python: ['.py'],
+    go: ['.go'],
+    rust: ['.rs']
+};
+// Config file patterns
+const CONFIG_PATTERNS = [
+    'package.json',
+    'tsconfig.json',
+    'build.gradle',
+    'build.gradle.kts',
+    'settings.gradle',
+    'settings.gradle.kts',
+    'pom.xml',
+    'Cargo.toml',
+    'go.mod',
+    'pyproject.toml',
+    'requirements.txt',
+    'Podfile',
+    '.env.example',
+    'docker-compose.yml',
+    'Dockerfile'
+];
+// Directories to skip
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.gradle',
+    'build',
+    'dist',
+    '__pycache__',
+    '.idea',
+    '.vscode',
+    'target',
+    '.next',
+    'venv',
+    'env',
+    '.pytest_cache',
+    'coverage',
+    '.nyc_output',
+    'Pods',
+    '.build',
+    'DerivedData'
+]);
+// Test patterns
+const TEST_PATTERNS = [
+    /\.test\.[jt]sx?$/,
+    /\.spec\.[jt]sx?$/,
+    /_test\.go$/,
+    /test_.*\.py$/,
+    /.*_test\.py$/,
+    /Test\.java$/,
+    /Test\.kt$/,
+    /Tests\.swift$/
+];
+/**
+ * Scan directory for source files
+ */
+async function scanSources(dir, projectType, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const sources = [];
+    const mainLanguage = getMainLanguage(projectType);
+    const extensions = getExtensionsForProject(projectType);
+    await walkDir(dir, dir, sources, extensions, opts);
+    // Sort by importance: config files first, then by size (smaller = more likely to be important)
+    sources.sort((a, b) => {
+        if (a.type === 'config' && b.type !== 'config')
+            return -1;
+        if (a.type !== 'config' && b.type === 'config')
+            return 1;
+        return a.size - b.size;
+    });
+    // Limit number of files
+    return sources.slice(0, opts.maxFiles);
+}
+/**
+ * Get main language for project type
+ */
+function getMainLanguage(projectType) {
+    const languageMap = {
+        android: 'kotlin',
+        ios: 'swift',
+        react: 'typescript',
+        next: 'typescript',
+        vue: 'typescript',
+        node: 'javascript',
+        python: 'python',
+        spring: 'java',
+        go: 'go',
+        rust: 'rust',
+        unknown: 'javascript'
+    };
+    return languageMap[projectType];
+}
+/**
+ * Get file extensions for project type
+ */
+function getExtensionsForProject(projectType) {
+    const mainLang = getMainLanguage(projectType);
+    const extensions = [...(LANGUAGE_EXTENSIONS[mainLang] || [])];
+    // Add related extensions
+    if (projectType === 'android') {
+        extensions.push(...LANGUAGE_EXTENSIONS.java, '.xml');
+    }
+    if (['react', 'next', 'vue', 'node'].includes(projectType)) {
+        extensions.push(...LANGUAGE_EXTENSIONS.javascript);
+    }
+    return extensions;
+}
+/**
+ * Recursively walk directory
+ */
+async function walkDir(rootDir, currentDir, sources, extensions, options) {
+    try {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            const relativePath = path.relative(rootDir, fullPath);
+            if (entry.isDirectory()) {
+                if (!SKIP_DIRS.has(entry.name)) {
+                    await walkDir(rootDir, fullPath, sources, extensions, options);
+                }
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name);
+                const isConfig = CONFIG_PATTERNS.includes(entry.name);
+                const isSource = extensions.includes(ext);
+                const isTest = TEST_PATTERNS.some(p => p.test(entry.name));
+                // Skip tests unless explicitly included
+                if (isTest && !options.includeTests)
+                    continue;
+                if (isConfig || isSource) {
+                    try {
+                        const stats = fs.statSync(fullPath);
+                        // Skip files that are too large
+                        if (stats.size > (options.maxFileSize || DEFAULT_OPTIONS.maxFileSize)) {
+                            continue;
+                        }
+                        sources.push({
+                            path: fullPath,
+                            relativePath,
+                            type: getFileType(entry.name, isConfig, isTest),
+                            language: getLanguageFromExtension(ext),
+                            size: stats.size
+                        });
+                    }
+                    catch {
+                        // Skip files we can't stat
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore directory read errors
+    }
+}
+/**
+ * Determine file type
+ */
+function getFileType(filename, isConfig, isTest) {
+    if (isConfig)
+        return 'config';
+    if (isTest)
+        return 'test';
+    if (filename.endsWith('.md') || filename.endsWith('.txt'))
+        return 'doc';
+    return 'code';
+}
+/**
+ * Get language from file extension
+ */
+function getLanguageFromExtension(ext) {
+    for (const [lang, exts] of Object.entries(LANGUAGE_EXTENSIONS)) {
+        if (exts.includes(ext))
+            return lang;
+    }
+    return undefined;
+}
+/**
+ * Read source file content (for LLM context)
+ */
+function readSourceContent(source) {
+    try {
+        return fs.readFileSync(source.path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get condensed context for LLM (file list with sizes)
+ */
+function getSourcesSummary(sources) {
+    const lines = ['Scanned source files:'];
+    const byType = new Map();
+    for (const source of sources) {
+        const list = byType.get(source.type) || [];
+        list.push(source);
+        byType.set(source.type, list);
+    }
+    for (const [type, files] of byType) {
+        lines.push(`\n[${type.toUpperCase()}]`);
+        for (const file of files) {
+            const sizeKB = (file.size / 1024).toFixed(1);
+            lines.push(`  ${file.relativePath} (${sizeKB}KB)`);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Get key files content for deep analysis
+ */
+function getKeyFilesContent(sources, maxTotalSize = 50000) {
+    const content = [];
+    let totalSize = 0;
+    // Prioritize config files
+    const configFiles = sources.filter(s => s.type === 'config');
+    const codeFiles = sources.filter(s => s.type === 'code');
+    for (const source of [...configFiles, ...codeFiles]) {
+        if (totalSize >= maxTotalSize)
+            break;
+        const fileContent = readSourceContent(source);
+        if (fileContent && totalSize + fileContent.length <= maxTotalSize) {
+            content.push(`\n--- ${source.relativePath} ---\n${fileContent}`);
+            totalSize += fileContent.length;
+        }
+    }
+    return content.join('\n');
+}

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

@@ -0,0 +1,60 @@
+/**
+ * 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
+ */
+import { AutoPilotContext, ProjectType } from './types';
+/**
+ * Speckit output structure
+ */
+export interface SpeckitOutput {
+    featureName: string;
+    planMd: string;
+    tasksMd: string;
+    outputDir: string;
+}
+/**
+ * Task in Speckit format
+ */
+export interface SpeckitTask {
+    id: string;
+    phase: number;
+    sequence: number;
+    title: string;
+    description: string;
+    files: string[];
+    dependencies: string[];
+    validation: string;
+    parallel: boolean;
+}
+/**
+ * Phase grouping
+ */
+export interface SpeckitPhase {
+    number: number;
+    name: string;
+    tasks: SpeckitTask[];
+}
+/**
+ * Generate Speckit files from AutoPilot context
+ */
+export declare function generateSpeckit(context: AutoPilotContext): SpeckitOutput;
+/**
+ * Save Speckit files to disk
+ */
+export declare function saveSpeckit(speckit: SpeckitOutput): {
+    planPath: string;
+    tasksPath: string;
+};
+/**
+ * Quick Speckit generation from just a prompt (without full analysis)
+ */
+export declare function generateQuickSpeckit(prompt: string, context: {
+    projectType: ProjectType;
+    projectName: string;
+    workingDir: string;
+}): SpeckitOutput;