sam-coder-cli 2.0.4 → 2.0.7

package/bin/ui.js

@@ -1,7 +1,14 @@
 const chalk = require('chalk');
 const ora = require('ora');
 
-const spinner = ora({ text: 'Thinking...', color: 'yellow', spinner: 'pipe' });
+// IMPORTANT: discardStdin must be false to prevent ora from closing stdin
+// which would cause readline to close and the program to exit
+const spinner = ora({
+  text: 'Thinking...',
+  color: 'yellow',
+  spinner: 'pipe',
+  discardStdin: false  // Critical: prevents stdin interference
+});
 
 // ASCII Art for AGI header
 const AGI_HEADER = `

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "sam-coder-cli",
-  "version": "2.0.4",
-  "description": "SAM-CODER: An animated command-line AI assistant with agency capabilities, brainstorm framework, and engineer mode.",
+  "version": "2.0.7",
+  "description": "SAM-CODER: An animated command-line AI assistant with agency capabilities.",
   "main": "bin/agi-cli.js",
   "bin": {
     "sam-coder": "bin/agi-cli.js",
     "agi-cli": "bin/agi-cli.js"
   },
+  "files": [
+    "bin",
+    "README.md"
+  ],
   "scripts": {
     "start": "node ./bin/agi-cli.js"
   },
@@ -16,29 +20,16 @@
     "cli",
     "terminal",
     "agent",
-    "brainstorm",
-    "engineer",
-    "code-generation"
+    "agi",
+    "deepseek"
   ],
-  "author": "",
+  "author": "Guilherme Keller",
   "license": "MIT",
   "dependencies": {
     "chalk": "^4.1.2",
-    "ora": "^5.4.1",
-    "ws": "^8.18.3"
-  },
-  "devDependencies": {
-    "@types/vscode": "^1.102.0",
-    "eslint": "^7.27.0"
+    "ora": "^5.4.1"
   },
   "engines": {
     "node": ">=18.12.1"
-  },
-  "files": [
-    "bin/**/*"
-  ],
-  "repository": {
-    "type": "git",
-    "url": ""
   }
-}
+}

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
-};