sam-coder-cli 1.0.69 → 2.0.1

package/bin/core/edit_finished_brainstorm.js

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

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

package/bin/core/index.js

@@ -0,0 +1,37 @@
+/**
+ * Brainstorm Core - Main Entry Point
+ * 
+ * Exports all brainstorm modules for use in the CLI.
+ */
+
+const models = require('./models');
+const brainstorm = require('./brainstorm');
+const finishBrainstorm = require('./finish_brainstorm');
+const editFinishedBrainstorm = require('./edit_finished_brainstorm');
+const templates = require('./templates');
+
+module.exports = {
+    // Models
+    ...models,
+
+    // Brainstorm
+    startBrainstorm: brainstorm.startBrainstorm,
+    getSession: brainstorm.getSession,
+    listFiles: brainstorm.listFiles,
+    quickStart: brainstorm.quickStart,
+
+    // Finish
+    finishBrainstorm: finishBrainstorm.finishBrainstorm,
+    getStatus: finishBrainstorm.getStatus,
+
+    // Edit
+    editBrainstormFile: editFinishedBrainstorm.editBrainstormFile,
+    getHistory: editFinishedBrainstorm.getHistory,
+    getVersions: editFinishedBrainstorm.getVersions,
+    restoreVersion: editFinishedBrainstorm.restoreVersion,
+    listBackups: editFinishedBrainstorm.listBackups,
+    EditResult: editFinishedBrainstorm.EditResult,
+
+    // Templates (for custom usage)
+    templates
+};