sam-coder-cli 2.0.4 → 2.0.5

package/bin/core/brainstorm.js

@@ -1,198 +0,0 @@
-/**
- * Brainstorm Module - Start a New Brainstorm Session
- * 
- * Initializes a new brainstorm session and generates all project coordination files.
- * Ported from Python to JavaScript.
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const { ProjectConfig, BrainstormSession } = require('./models');
-const templates = require('./templates');
-
-/**
- * File templates mapping
- */
-const FILE_TEMPLATES = {
-    'CLAUDE.md': templates.generateClaudeMd,
-    'PROJECT_STATUS.md': templates.generateProjectStatusMd,
-    'PROGRESS_REPORT.md': templates.generateProgressReportMd,
-    'GETTING_STARTED.md': templates.generateGettingStartedMd,
-    'SELF_IMPROVEMENT.md': templates.generateSelfImprovementMd,
-    'CEO-UPDATES-TODAY.md': templates.generateCeoUpdatesMd,
-    'CODE_OF_CONDUCT_OF_AI_WORKERS.md': templates.generateCodeOfConductMd
-};
-
-const MULTI_AGENT_TEMPLATES = {
-    'SECONDARY-AI-CHAT.md': templates.generateSecondaryAiChatMd
-};
-
-/**
- * Start a new brainstorm session
- * 
- * @param {Object} options
- * @param {ProjectConfig|Object} options.config - Project configuration
- * @param {string} options.outputDir - Directory where files will be generated
- * @param {string[]} options.agents - List of agent identities (e.g., ["CLAUDE-1", "CLAUDE-2"])
- * @returns {Promise<BrainstormSession>}
- */
-async function startBrainstorm({ config, outputDir, agents = ['CLAUDE-1'] }) {
-    // Convert to ProjectConfig if needed
-    const project = config instanceof ProjectConfig ? config : new ProjectConfig(config);
-
-    // Create output directory
-    await fs.mkdir(outputDir, { recursive: true });
-
-    // Create new session
-    const session = BrainstormSession.create({
-        project,
-        outputDirectory: outputDir,
-        agents
-    });
-
-    const generatedFiles = [];
-
-    // Generate standard files
-    for (const [fileName, templateFn] of Object.entries(FILE_TEMPLATES)) {
-        const content = templateFn({ project, agents, session });
-        const filePath = path.join(outputDir, fileName);
-        await fs.writeFile(filePath, content, 'utf-8');
-        generatedFiles.push(fileName);
-        session.fileVersions[fileName] = 1;
-    }
-
-    // Generate multi-agent files if more than one agent
-    if (agents.length > 1) {
-        for (const [fileName, templateFn] of Object.entries(MULTI_AGENT_TEMPLATES)) {
-            const content = templateFn({ project, agents, session });
-            const filePath = path.join(outputDir, fileName);
-            await fs.writeFile(filePath, content, 'utf-8');
-            generatedFiles.push(fileName);
-            session.fileVersions[fileName] = 1;
-        }
-    }
-
-    // Create directory structure if defined
-    if (project.directoryStructure && Object.keys(project.directoryStructure).length > 0) {
-        await createDirectoryStructure(outputDir, project.directoryStructure);
-    }
-
-    // Add event for file generation
-    session.addEvent({
-        eventType: 'UPDATED',
-        actor: 'BRAINSTORM',
-        description: `Generated ${generatedFiles.length} project files`,
-        affectedFiles: generatedFiles
-    });
-
-    // Save session state
-    await session.save();
-
-    return session;
-}
-
-/**
- * Create directory structure recursively
- */
-async function createDirectoryStructure(baseDir, structure, currentPath = null) {
-    const current = currentPath || baseDir;
-
-    for (const [name, children] of Object.entries(structure)) {
-        const itemPath = path.join(current, name);
-
-        if (typeof children === 'object' && children !== null && Object.keys(children).length > 0) {
-            // Directory with children
-            await fs.mkdir(itemPath, { recursive: true });
-            await createDirectoryStructure(baseDir, children, itemPath);
-        } else if (children === null || (typeof children === 'object' && Object.keys(children).length === 0)) {
-            // Empty directory
-            await fs.mkdir(itemPath, { recursive: true });
-        } else {
-            // File placeholder
-            await fs.mkdir(path.dirname(itemPath), { recursive: true });
-            try {
-                await fs.access(itemPath);
-            } catch {
-                await fs.writeFile(itemPath, '', 'utf-8');
-            }
-        }
-    }
-}
-
-/**
- * Load an existing session from a directory
- * 
- * @param {string} sessionDir - Directory containing SESSION.json
- * @returns {Promise<BrainstormSession|null>}
- */
-async function getSession(sessionDir) {
-    const sessionFile = path.join(sessionDir, 'SESSION.json');
-
-    try {
-        await fs.access(sessionFile);
-        return await BrainstormSession.load(sessionFile);
-    } catch {
-        return null;
-    }
-}
-
-/**
- * List all files in a brainstorm session with their versions
- * 
- * @param {BrainstormSession} session
- * @returns {Array<Object>}
- */
-async function listFiles(session) {
-    const files = [];
-
-    for (const [fileName, version] of Object.entries(session.fileVersions)) {
-        const filePath = path.join(session.outputDirectory, fileName);
-        let exists = false;
-
-        try {
-            await fs.access(filePath);
-            exists = true;
-        } catch { }
-
-        files.push({
-            name: fileName,
-            path: filePath,
-            version,
-            exists
-        });
-    }
-
-    return files;
-}
-
-/**
- * Quick start function for creating a brainstorm session
- * 
- * @param {string} name - Project name
- * @param {string} description - Project description
- * @param {string} outputDir - Output directory
- * @param {string[]} agents - List of agent identities
- * @param {Object} options - Additional ProjectConfig fields
- * @returns {Promise<BrainstormSession>}
- */
-async function quickStart(name, description, outputDir, agents = ['CLAUDE-1'], options = {}) {
-    const config = new ProjectConfig({
-        name,
-        description,
-        ...options
-    });
-
-    return startBrainstorm({
-        config,
-        outputDir,
-        agents
-    });
-}
-
-module.exports = {
-    startBrainstorm,
-    getSession,
-    listFiles,
-    quickStart,
-    createDirectoryStructure
-};

package/bin/core/edit_finished_brainstorm.js

@@ -1,294 +0,0 @@
-/**
- * Edit Finished Brainstorm Module - Version-Tracked Edits
- * 
- * Allows editing of completed brainstorm files with full version tracking and audit trail.
- * Ported from Python to JavaScript.
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const { BrainstormSession, EditInfo } = require('./models');
-
-/**
- * Result of an edit operation
- */
-class EditResult {
-    constructor({
-        success,
-        fileName,
-        versionBefore,
-        versionAfter,
-        backupPath = null,
-        error = null
-    }) {
-        this.success = success;
-        this.fileName = fileName;
-        this.versionBefore = versionBefore;
-        this.versionAfter = versionAfter;
-        this.backupPath = backupPath;
-        this.error = error;
-    }
-}
-
-/**
- * Edit a file in a completed brainstorm session
- * 
- * @param {Object} options
- * @param {string} options.sessionDir - Directory containing the session
- * @param {string} options.fileName - Name of the file to edit
- * @param {string} options.newContent - New content for the file
- * @param {string} options.description - Description of what was changed
- * @param {string} options.editor - Who is making the edit
- * @returns {Promise<EditResult>}
- */
-async function editBrainstormFile({ sessionDir, fileName, newContent, description, editor = 'HUMAN' }) {
-    const sessionFile = path.join(sessionDir, 'SESSION.json');
-
-    // Check if session exists
-    try {
-        await fs.access(sessionFile);
-    } catch {
-        return new EditResult({
-            success: false,
-            fileName,
-            versionBefore: 0,
-            versionAfter: 0,
-            error: 'SESSION.json not found'
-        });
-    }
-
-    // Load session
-    const session = await BrainstormSession.load(sessionFile);
-    const filePath = path.join(session.outputDirectory, fileName);
-
-    // Check if file exists
-    try {
-        await fs.access(filePath);
-    } catch {
-        return new EditResult({
-            success: false,
-            fileName,
-            versionBefore: 0,
-            versionAfter: 0,
-            error: `File ${fileName} does not exist in session`
-        });
-    }
-
-    // Get current version
-    const versionBefore = session.getFileVersion(fileName);
-
-    // Create backup
-    const backupPath = await createBackup(session, filePath, versionBefore);
-
-    // Write new content
-    await fs.writeFile(filePath, newContent, 'utf-8');
-
-    // Increment version
-    const versionAfter = session.incrementFileVersion(fileName);
-
-    // Add event to session history
-    session.addEvent({
-        eventType: 'EDITED',
-        actor: editor,
-        description: `Edited ${fileName}: ${description}`,
-        affectedFiles: [fileName]
-    });
-
-    // Save updated session
-    await session.save();
-
-    return new EditResult({
-        success: true,
-        fileName,
-        versionBefore,
-        versionAfter,
-        backupPath
-    });
-}
-
-/**
- * Create a versioned backup of a file
- * 
- * @param {BrainstormSession} session
- * @param {string} filePath - Path to the file
- * @param {number} version - Current version number
- * @returns {Promise<string|null>}
- */
-async function createBackup(session, filePath, version) {
-    const backupsDir = path.join(session.outputDirectory, '.backups');
-
-    try {
-        await fs.mkdir(backupsDir, { recursive: true });
-    } catch { }
-
-    const fileName = path.basename(filePath);
-    const backupName = `${fileName}.v${version}`;
-    const backupPath = path.join(backupsDir, backupName);
-
-    try {
-        await fs.copyFile(filePath, backupPath);
-        return backupPath;
-    } catch (error) {
-        console.error(`Failed to create backup: ${error.message}`);
-        return null;
-    }
-}
-
-/**
- * Get edit history for a session or specific file
- * 
- * @param {string} sessionDir - Directory containing the session
- * @param {string|null} fileName - Optional file name to filter by
- * @returns {Promise<Array>}
- */
-async function getHistory(sessionDir, fileName = null) {
-    const sessionFile = path.join(sessionDir, 'SESSION.json');
-
-    try {
-        await fs.access(sessionFile);
-    } catch {
-        return [];
-    }
-
-    const session = await BrainstormSession.load(sessionFile);
-
-    // Filter for EDITED events
-    let edits = session.history
-        .filter(e => e.eventType === 'EDITED')
-        .map(e => e.toJSON ? e.toJSON() : e);
-
-    // Filter by file name if specified
-    if (fileName) {
-        edits = edits.filter(e =>
-            (e.affectedFiles || []).includes(fileName)
-        );
-    }
-
-    return edits;
-}
-
-/**
- * Get current versions of all files in a session
- * 
- * @param {string} sessionDir - Directory containing the session
- * @returns {Promise<Object>}
- */
-async function getVersions(sessionDir) {
-    const sessionFile = path.join(sessionDir, 'SESSION.json');
-
-    try {
-        await fs.access(sessionFile);
-    } catch {
-        return {};
-    }
-
-    const session = await BrainstormSession.load(sessionFile);
-    return { ...session.fileVersions };
-}
-
-/**
- * Restore a file to a previous version
- * 
- * @param {Object} options
- * @param {string} options.sessionDir - Directory containing the session
- * @param {string} options.fileName - Name of the file to restore
- * @param {number} options.version - Version number to restore to
- * @param {string} options.editor - Who is making the restore
- * @returns {Promise<EditResult>}
- */
-async function restoreVersion({ sessionDir, fileName, version, editor = 'HUMAN' }) {
-    const sessionFile = path.join(sessionDir, 'SESSION.json');
-
-    try {
-        await fs.access(sessionFile);
-    } catch {
-        return new EditResult({
-            success: false,
-            fileName,
-            versionBefore: 0,
-            versionAfter: 0,
-            error: 'SESSION.json not found'
-        });
-    }
-
-    const session = await BrainstormSession.load(sessionFile);
-
-    // Find backup file
-    const backupsDir = path.join(session.outputDirectory, '.backups');
-    const backupPath = path.join(backupsDir, `${fileName}.v${version}`);
-
-    try {
-        await fs.access(backupPath);
-    } catch {
-        return new EditResult({
-            success: false,
-            fileName,
-            versionBefore: session.getFileVersion(fileName),
-            versionAfter: session.getFileVersion(fileName),
-            error: `Backup version ${version} not found for ${fileName}`
-        });
-    }
-
-    // Read backup content
-    const content = await fs.readFile(backupPath, 'utf-8');
-
-    // Use edit to restore (this creates a new version)
-    return editBrainstormFile({
-        sessionDir,
-        fileName,
-        newContent: content,
-        description: `Restored to version ${version}`,
-        editor
-    });
-}
-
-/**
- * List all backup files in a session
- * 
- * @param {string} sessionDir - Directory containing the session
- * @returns {Promise<Array>}
- */
-async function listBackups(sessionDir) {
-    const backupsDir = path.join(sessionDir, '.backups');
-
-    try {
-        await fs.access(backupsDir);
-    } catch {
-        return [];
-    }
-
-    const entries = await fs.readdir(backupsDir, { withFileTypes: true });
-    const backups = [];
-
-    for (const entry of entries) {
-        if (entry.isFile()) {
-            const match = entry.name.match(/^(.+)\.v(\d+)$/);
-            if (match) {
-                const filePath = path.join(backupsDir, entry.name);
-                const stats = await fs.stat(filePath);
-
-                backups.push({
-                    fileName: match[1],
-                    version: parseInt(match[2], 10),
-                    backupPath: filePath,
-                    size: stats.size,
-                    modified: stats.mtime.toISOString()
-                });
-            }
-        }
-    }
-
-    return backups.sort((a, b) => {
-        if (a.fileName !== b.fileName) return a.fileName.localeCompare(b.fileName);
-        return a.version - b.version;
-    });
-}
-
-module.exports = {
-    EditResult,
-    editBrainstormFile,
-    getHistory,
-    getVersions,
-    restoreVersion,
-    listBackups
-};

package/bin/core/finish_brainstorm.js

@@ -1,217 +0,0 @@
-/**
- * Finish Brainstorm Module - Complete a Brainstorm Session
- * 
- * Finalizes a brainstorm session, generates mutual summaries,
- * and marks the session as completed.
- * Ported from Python to JavaScript.
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const { BrainstormSession, SessionResult } = require('./models');
-
-/**
- * Complete a brainstorm session
- * 
- * @param {Object} options
- * @param {string} options.sessionDir - Directory containing the session
- * @param {string} options.summary - Summary of what was accomplished
- * @param {string} options.actor - Who is completing the session
- * @param {string[]} options.nextSteps - Optional list of next steps
- * @returns {Promise<SessionResult>}
- */
-async function finishBrainstorm({ sessionDir, summary, actor = 'CLAUDE-1', nextSteps = [] }) {
-    const sessionFile = path.join(sessionDir, 'SESSION.json');
-
-    // Check if session exists
-    try {
-        await fs.access(sessionFile);
-    } catch {
-        return new SessionResult({
-            success: false,
-            sessionId: '',
-            status: 'FAILED',
-            summary: 'Session file not found',
-            errors: ['SESSION.json not found in the specified directory']
-        });
-    }
-
-    // Load session
-    const session = await BrainstormSession.load(sessionFile);
-
-    // Check if already completed
-    if (session.status === 'COMPLETED') {
-        return new SessionResult({
-            success: false,
-            sessionId: session.id,
-            status: 'ALREADY_COMPLETED',
-            summary: 'Session was already completed',
-            errors: ['Session is already in COMPLETED status']
-        });
-    }
-
-    // Generate mutual summary
-    const mutualSummary = generateMutualSummary({ session, summary, actor, nextSteps });
-
-    // Update PROGRESS_REPORT.md with completion info
-    await updateProgressReport({ session, mutualSummary, actor });
-
-    // Update SECONDARY-AI-CHAT.md if it exists
-    const secondaryChatPath = path.join(session.outputDirectory, 'SECONDARY-AI-CHAT.md');
-    try {
-        await fs.access(secondaryChatPath);
-        await updateSecondaryChat({ session, summary, actor });
-    } catch { }
-
-    // Mark session as completed
-    session.status = 'COMPLETED';
-    session.mutualSummary = summary;
-
-    // Add completion event
-    session.addEvent({
-        eventType: 'COMPLETED',
-        actor,
-        description: `Session completed: ${summary}`,
-        affectedFiles: Object.keys(session.fileVersions)
-    });
-
-    // Save updated session
-    await session.save();
-
-    return new SessionResult({
-        success: true,
-        sessionId: session.id,
-        status: 'COMPLETED',
-        summary,
-        filesGenerated: Object.keys(session.fileVersions)
-    });
-}
-
-/**
- * Generate the mutual summary text
- */
-function generateMutualSummary({ session, summary, actor, nextSteps }) {
-    const timestamp = new Date().toISOString();
-
-    let result = `
-## 🏁 MUTUAL SUMMARY
-
-**Session ID**: ${session.id}
-**Completed At**: ${timestamp}
-**Completed By**: ${actor}
-
-### What Was Accomplished:
-${summary}
-
-`;
-
-    if (nextSteps && nextSteps.length > 0) {
-        result += '### Next Steps:\n';
-        nextSteps.forEach((step, i) => {
-            result += `${i + 1}. ${step}\n`;
-        });
-        result += '\n';
-    }
-
-    // Add history summary (last 5 events)
-    result += '### Session History:\n';
-    const recentEvents = session.history.slice(-5);
-    recentEvents.forEach(event => {
-        result += `- [${event.eventType}] ${event.description} (${event.actor})\n`;
-    });
-
-    return result;
-}
-
-/**
- * Update PROGRESS_REPORT.md with completion information
- */
-async function updateProgressReport({ session, mutualSummary, actor }) {
-    const progressFile = path.join(session.outputDirectory, 'PROGRESS_REPORT.md');
-
-    try {
-        await fs.access(progressFile);
-    } catch {
-        return; // File doesn't exist
-    }
-
-    // Read current content
-    let content = await fs.readFile(progressFile, 'utf-8');
-
-    // Add completion block
-    const completionBlock = `
-
----
-
-${mutualSummary}
-
----
-
-**Final Status**: COMPLETED
-**Last Updated**: ${new Date().toISOString().replace('T', ' ').split('.')[0]} by ${actor}
-`;
-
-    content += completionBlock;
-    await fs.writeFile(progressFile, content, 'utf-8');
-
-    // Increment version
-    session.incrementFileVersion('PROGRESS_REPORT.md');
-}
-
-/**
- * Update SECONDARY-AI-CHAT.md with completion log
- */
-async function updateSecondaryChat({ session, summary, actor }) {
-    const chatFile = path.join(session.outputDirectory, 'SECONDARY-AI-CHAT.md');
-
-    try {
-        await fs.access(chatFile);
-    } catch {
-        return; // File doesn't exist
-    }
-
-    // Read current content
-    let content = await fs.readFile(chatFile, 'utf-8');
-
-    // Add completion entry
-    const completionEntry = `
----
-
-[${actor}] COMPLETED: Session completed
-Timestamp: ${new Date().toISOString()}
-Summary: ${summary}
-Status: SUCCESS ✅
-Notes: All brainstorm files finalized. Session ready for execution phase.
-
----
-`;
-
-    content += completionEntry;
-    await fs.writeFile(chatFile, content, 'utf-8');
-
-    // Increment version
-    session.incrementFileVersion('SECONDARY-AI-CHAT.md');
-}
-
-/**
- * Get the current status of a session
- * 
- * @param {string} sessionDir - Directory containing the session
- * @returns {Promise<string>}
- */
-async function getStatus(sessionDir) {
-    const sessionFile = path.join(sessionDir, 'SESSION.json');
-
-    try {
-        await fs.access(sessionFile);
-        const session = await BrainstormSession.load(sessionFile);
-        return session.status;
-    } catch {
-        return 'NOT_FOUND';
-    }
-}
-
-module.exports = {
-    finishBrainstorm,
-    getStatus
-};