@full-self-developing/fsd 1.0.0

package/agents/base.js

@@ -0,0 +1,280 @@
+/**
+ * base.js — Shared utilities for all loop agents
+ */
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+const { serverLog, errorLog } = require('../logger');
+const { getDriver }        = require('./drivers');
+const { getCurrentEngine, getWorkspacePath } = require('./engine-config');
+
+/**
+ * FSD_ROOT — The directory where the FSD system itself lives.
+ * Used for internal log/queue paths only.
+ */
+const FSD_ROOT = path.resolve(__dirname, '..');
+
+/**
+ * getProjectCWD() — Returns the absolute path of the TARGET project.
+ * Priority:
+ *  1. Workspace path saved in engine-config.json (set via UI "Open Project")
+ *  2. Falls back to FSD_ROOT itself (original behaviour, useful during dev)
+ */
+function getProjectCWD() {
+    return getWorkspacePath() || FSD_ROOT;
+}
+
+/**
+ * CWD — legacy export kept for backward compat.
+ * Always call getProjectCWD() in hot paths so workspace changes are picked up
+ * without restarting the server.
+ * @deprecated use getProjectCWD() for anything that depends on the workspace
+ */
+const CWD = FSD_ROOT;
+
+const QUEUE_FILE     = path.join(FSD_ROOT, 'queue', 'tasks.json');
+const LOOP_LOGS_DIR  = path.join(FSD_ROOT, 'logs', 'loop');
+
+// ── SSE Broadcast ────────────────────────────────────────────────────────────
+const sseClients = new Set();
+
+function registerSSEClient(res) {
+    sseClients.add(res);
+    res.on('close', () => sseClients.delete(res));
+}
+
+function broadcast(event, data) {
+    const msg = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+    for (const client of sseClients) {
+        try { client.write(msg); } catch (_) { sseClients.delete(client); }
+    }
+}
+
+function enrichTask(task) {
+    if (!task) return null;
+    
+    // 1. Error reason at top level
+    const error_reason = task.error || null;
+    
+    // 2. Progress status at top level
+    const progress_status = task.status || 'pending';
+    
+    // 3. Expose affected files
+    const files = [];
+    if (task.plan && Array.isArray(task.plan.steps)) {
+        for (const step of task.plan.steps) {
+            const stepFiles = Array.isArray(step.file) ? step.file : [step.file];
+            for (const f of stepFiles) {
+                if (f && typeof f === 'string') {
+                    files.push(f);
+                }
+            }
+        }
+    }
+    if (task.suggestion && Array.isArray(task.suggestion.files)) {
+        for (const f of task.suggestion.files) {
+            if (f && typeof f === 'string') {
+                files.push(f);
+            }
+        }
+    }
+    if (task.coding_log && Array.isArray(task.coding_log)) {
+        for (const log of task.coding_log) {
+            if (log.file && typeof log.file === 'string') {
+                files.push(log.file);
+            }
+        }
+    }
+    const affected_files = [...new Set(files)].map(f => f.replace(/\\/g, '/'));
+
+    return {
+        ...task,
+        error_reason,
+        progress_status,
+        affected_files
+    };
+}
+
+// ── Task Store ───────────────────────────────────────────────────────────────
+function loadTasks(includeDeleted = false) {
+    try {
+        if (fs.existsSync(QUEUE_FILE)) {
+            const tasks = JSON.parse(fs.readFileSync(QUEUE_FILE, 'utf8'));
+            if (includeDeleted) return tasks.map(enrichTask);
+            return tasks.filter(t => !t.deleted).map(enrichTask);
+        }
+    } catch (_) {}
+    return [];
+}
+
+function saveTasks(tasks) {
+    fs.mkdirSync(path.dirname(QUEUE_FILE), { recursive: true });
+    fs.writeFileSync(QUEUE_FILE, JSON.stringify(tasks, null, 2));
+}
+
+function createTask(type = 'loop') {
+    const task = {
+        id:          uuidv4(),
+        type,
+        status:      'pending',
+        suggestion:  null,
+        review:      null,
+        plan:        null,
+        review_log:  [],
+        coding_log:  [],
+        test_results: null,
+        summary:     null,
+        created_at:  new Date().toISOString(),
+        updated_at:  new Date().toISOString(),
+    };
+    const tasks = loadTasks(true);
+    tasks.unshift(task);
+    saveTasks(tasks);
+    const enriched = enrichTask(task);
+    broadcast('task_created', enriched);
+    return enriched;
+}
+
+function updateTask(id, patch) {
+    const tasks = loadTasks(true);
+    const idx   = tasks.findIndex(t => t.id === id);
+    if (idx === -1) return null;
+    
+    const updatedTask = { ...tasks[idx], ...patch, updated_at: new Date().toISOString() };
+    if (patch.deleted === false) {
+        delete updatedTask.deleted;
+        delete updatedTask.deleted_at;
+    }
+    
+    tasks[idx] = enrichTask(updatedTask);
+    saveTasks(tasks);
+    broadcast('task_updated', tasks[idx]);
+
+    // Persist task snapshot to project-local logs/loop/<task-id>/task.json
+    try {
+        const taskLogDir = path.join(LOOP_LOGS_DIR, id);
+        fs.mkdirSync(taskLogDir, { recursive: true });
+        fs.writeFileSync(
+            path.join(taskLogDir, 'task.json'),
+            JSON.stringify(tasks[idx], null, 2)
+        );
+    } catch (e) {
+        // Non-fatal: don't crash the agent pipeline on log write failure
+        console.error('[base] Failed to write task snapshot:', e.message);
+    }
+
+    return tasks[idx];
+}
+
+function getTask(id) {
+    return loadTasks().find(t => t.id === id) || null;
+}
+
+/**
+ * appendStepLog(taskId, stepData)
+ * Appends a single step event line to logs/loop/<taskId>/steps.jsonl.
+ * Call this from dispatcher after each agent phase completes.
+ */
+function appendStepLog(taskId, stepData) {
+    try {
+        const logDir  = path.join(LOOP_LOGS_DIR, taskId);
+        fs.mkdirSync(logDir, { recursive: true });
+        const logFile = path.join(logDir, 'steps.jsonl');
+        const entry   = { ...stepData, recorded_at: new Date().toISOString() };
+        fs.appendFileSync(logFile, JSON.stringify(entry) + '\n');
+    } catch (e) {
+        console.error('[base] Failed to append step log:', e.message);
+    }
+}
+
+const DEFAULT_MODEL = 'deepseek/deepseek-chat:free';
+
+// ── AI Model Runner ──────────────────────────────────────────────────────────
+
+/**
+ * runModel(prompt, model, options)
+ * Unified AI model runner — routes to the appropriate driver via the registry.
+ *
+ * @param {string} prompt     - prompt text
+ * @param {string} [model]    - model name (ignored by some drivers)
+ * @param {object} [options]  - { engine, cwd, timeout }
+ * @returns {Promise<string>}
+ */
+async function runModel(prompt, model = DEFAULT_MODEL, options = {}) {
+    const engine = options.engine;
+    const driver = getDriver(engine);
+    const driverOptions = { ...options, model };
+    serverLog(`[runModel] engine=${driver.name} model=${model || 'default'}`);
+    return driver.run(prompt, driverOptions);
+}
+
+function getDefaultModelForEngine(engine) {
+    if (engine === 'gemini-cli') return 'gemini-2.5-flash';
+    if (engine === 'atomcode') return null;
+    return 'deepseek/deepseek-chat:free';
+}
+
+/**
+ * runGemini(prompt, model)
+ * Universal agent model runner — uses the currently configured engine.
+ * Reads engine selection from engine-config.json (set via UI toggle).
+ * Delegates to runModel with the active engine.
+ */
+async function runGemini(prompt, model = null) {
+    const engine = getCurrentEngine();
+    const activeModel = require('./engine-config').getActiveModel();
+    let resolvedModel = activeModel || model || getDefaultModelForEngine(engine);
+
+    if (engine === 'atomcode') {
+        // atomcode 引擎有自己的模型列表（来自 ~/.atomcode/config.toml）。
+        // Agent 硬编码的 OpenRouter 模型名（gemini-2.5-flash, gemini-2.5-pro）
+        // 对 atomcode 无意义。只透传 atomcode 已知的模型名，其余让 CLI 用默认。
+        if (!resolvedModel) {
+            resolvedModel = null;
+        } else {
+            // 检查是否属于 atomcode 已知模型
+            const { getAtomCodeModels } = require('./engine-config');
+            const known = getAtomCodeModels();
+            if (!known.some(m => m.id === resolvedModel)) {
+                resolvedModel = null; // 不是 atomcode 模型名 → 用 CLI 默认
+            }
+        }
+    }
+    return runModel(prompt, resolvedModel, { engine, cwd: getProjectCWD() });
+}
+function extractJSON(text) {
+    // 1. Try ```json ... ``` code blocks
+    const block = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (block) {
+        try { return JSON.parse(block[1].trim()); } catch (_) {}
+    }
+    // 2. Try first {...} or [...] span
+    const obj = text.match(/\{[\s\S]*\}/);
+    if (obj) {
+        try { return JSON.parse(obj[0]); } catch (_) {}
+    }
+    const arr = text.match(/\[[\s\S]*\]/);
+    if (arr) {
+        try { return JSON.parse(arr[0]); } catch (_) {}
+    }
+    errorLog('[extractJSON] Failed to parse JSON from agent output. Raw text:', text);
+    throw new Error(`No valid JSON found in agent output. Raw output snippet: ${text.slice(0, 300)}`);
+}
+
+module.exports = {
+    CWD,
+    getProjectCWD,
+    runGemini,
+    runModel,
+    extractJSON,
+    loadTasks,
+    saveTasks,
+    createTask,
+    updateTask,
+    getTask,
+    appendStepLog,
+    registerSSEClient,
+    broadcast,
+};

package/agents/branch-manager.js

@@ -0,0 +1,135 @@
+/**
+ * branch-manager.js — Agent 8: Archives changes into isolation branch without junk files
+ */
+'use strict';
+
+const { spawn } = require('child_process');
+const path = require('path');
+const { getProjectCWD } = require('./base');
+
+/**
+ * Run a git command in the given directory.
+ * shell: false — Node passes each array element as a separate argv,
+ * so spaces / Chinese chars / colons in commit messages are safe.
+ */
+function gitCmd(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, { cwd, shell: false });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', d => stdout += d.toString());
+        child.stderr.on('data', d => stderr += d.toString());
+        child.on('close', code => {
+            if (code === 0) resolve(stdout.trim());
+            else {
+                const detail = [stderr.trim(), stdout.trim()].filter(Boolean).join(' | ');
+                reject(new Error(`git ${args[0]} failed: ${detail || '(no output)'}`));
+            }
+        });
+    });
+}
+
+
+async function archiveTask(task) {
+    const branchName = task.plan?.branch_name || `feat/task-${task.id.slice(0, 8)}`;
+    // Resolve at runtime so workspace changes are picked up without restart
+    const projectCWD = getProjectCWD();
+    console.log(`[BranchManager] Archiving to branch '${branchName}' in ${projectCWD}...`);
+
+    // Convenience wrapper — binds projectCWD automatically
+    const git = (...args) => gitCmd(args, projectCWD);
+
+    try {
+        // Step 1: Ensure we are on master/main before any branch operations.
+        //   (prevents `branch -D` failing if a previous crash left us on the feature branch)
+        const currentBranch = await git('rev-parse', '--abbrev-ref', 'HEAD');
+        if (currentBranch !== 'master' && currentBranch !== 'main') {
+            console.log(`[BranchManager] On '${currentBranch}', switching to master first...`);
+            await git('checkout', '-f', 'master').catch(() => git('checkout', '-f', 'main'));
+        }
+
+        // Step 2: Delete the feature branch if it already exists (idempotent retry support)
+        const existing = await git('branch', '--list', branchName);
+        if (existing.trim()) {
+            console.log(`[BranchManager] Branch '${branchName}' exists, removing for clean recreate...`);
+            await git('branch', '-D', branchName);
+        }
+
+        // Step 3: Create and checkout the feature branch
+        await git('checkout', '-b', branchName);
+
+        // Step 4: Stage only files that git itself reports as modified/new,
+        //   filtered to known code extensions — completely avoids .gitignore conflicts.
+        const CODE_EXTS = new Set(['.php', '.js', '.css', '.html', '.vue', '.ts', '.json']);
+
+        // `git status --short` lines: "XY filename" or "XY old -> new"
+        const statusOut = await git('status', '--short');
+        const changedFiles = statusOut
+            .split('\n')
+            .map(l => l.trim())
+            .filter(Boolean)
+            .map(l => {
+                // Handle renames: "R old -> new"
+                const parts = l.slice(2).trim().split(' -> ');
+                return parts[parts.length - 1].replace(/^"|"$/g, '').trim();
+            })
+            .filter(f => CODE_EXTS.has(path.extname(f)));
+
+        // Also always include the specific files from coding_log
+        const logFiles = (task.coding_log || []).map(l => l.file).filter(Boolean);
+
+        // Merge and deduplicate
+        const toStage = [...new Set([...changedFiles, ...logFiles])];
+
+        if (toStage.length === 0) {
+            throw new Error('No modified code files to stage — git reports no changes in tracked code files.');
+        }
+
+        // Stage one by one so a single problem file doesn't abort the whole batch
+        let staged = false;
+        for (const f of toStage) {
+            await git('add', '--', f).then(() => { staged = true; }).catch(e =>
+                console.warn(`[BranchManager] Skipping '${f}': ${e.message}`)
+            );
+        }
+
+        if (!staged) {
+            throw new Error('All staging attempts failed — see warnings above.');
+        }
+
+        // Step 5: Commit only if there are actual staged changes.
+        // Use `git diff --cached --quiet` — exits 0 if nothing staged, 1 if there are staged changes.
+        // This is more reliable than parsing `status --porcelain` output.
+        let hasStagedChanges = false;
+        try {
+            await git('diff', '--cached', '--quiet');
+            // exit 0 = nothing staged
+            hasStagedChanges = false;
+        } catch (_) {
+            // exit 1 = there ARE staged changes (this is the normal "has changes" signal)
+            hasStagedChanges = true;
+        }
+
+        if (hasStagedChanges) {
+            const commitMsg = `feat: ${task.plan?.title || 'auto optimize task'}`;
+            await git('commit', '-m', commitMsg);
+            console.log(`[BranchManager] Committed to '${branchName}': ${commitMsg}`);
+        } else {
+            console.log(`[BranchManager] No staged changes to commit (working tree already clean).`);
+        }
+
+        // Step 6: Return to master
+        await git('checkout', 'master');
+        return { branch: branchName, status: 'archived' };
+
+    } catch (err) {
+        console.error(`[BranchManager] Error:`, err.message);
+        // Best-effort cleanup: switch back so repo isn't left in a bad state
+        await gitCmd(['checkout', '-f', 'master'], projectCWD).catch(() =>
+            gitCmd(['checkout', '-f', 'main'], projectCWD).catch(() => {})
+        );
+        throw err;
+    }
+}
+
+module.exports = { archiveTask };

package/agents/cli-models.json

@@ -0,0 +1,48 @@
+{
+  "gemini-cli": [
+    { "id": "gemini-3-pro-preview" },
+    { "id": "gemini-3-flash-preview" },
+    { "id": "gemini-2.5-pro" },
+    { "id": "gemini-2.5-flash" },
+    { "id": "gemini-2.5-flash-lite" },
+    { "id": "gemini-2.0-flash" },
+    { "id": "gemini-2.0-flash-lite" }
+  ],
+  "codex": [
+    { "id": "gpt-5.5" },
+    { "id": "gpt-5.4" },
+    { "id": "gpt-5.3-codex" },
+    { "id": "gpt-5.2-codex" },
+    { "id": "gpt-5.1-codex" },
+    { "id": "gpt-5-codex" },
+    { "id": "gpt-4o" },
+    { "id": "gpt-4o-mini" },
+    { "id": "claude-3-7-sonnet" },
+    { "id": "claude-3-5-sonnet" },
+    { "id": "o1" },
+    { "id": "o3-mini" },
+    { "id": "o3" },
+    { "id": "o4-mini" }
+  ],
+  "claude-cli": [
+    { "id": "claude-3-7-sonnet" },
+    { "id": "claude-3-5-sonnet" },
+    { "id": "claude-3-5-haiku" },
+    { "id": "claude-3-opus" }
+  ],
+  "openshell": [
+    { "id": "gpt-4o" },
+    { "id": "gpt-4o-mini" },
+    { "id": "claude-3-7-sonnet" },
+    { "id": "gemini-2.5-pro" }
+  ],
+  "tts-local-cli": [
+    { "id": "kokoro" },
+    { "id": "edge-tts" },
+    { "id": "piper" },
+    { "id": "coqui-tts" }
+  ],
+  "skill-workshop": [
+    { "id": "default-skill-model" }
+  ]
+}

package/agents/coder.js

@@ -0,0 +1,128 @@
+/**
+ * coder.js — Agent 5: Programming Agent
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { runGemini, getProjectCWD } = require('./base');
+const promptManager = require('./prompt-manager');
+const { enforceBoundary } = require('./path-validator');
+
+/** Detect the fenced code block language tag from a file extension */
+function langTag(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const map = { '.php': 'php', '.js': 'javascript', '.ts': 'typescript', '.json': 'json', '.css': 'css', '.html': 'html', '.md': 'markdown' };
+    return map[ext] || '';
+}
+
+/** Return true if text looks like source code (not AI prose) */
+function looksLikeCode(text, filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const trimmed = text.trim();
+    if (ext === '.php') {
+        // Accept <?php or <? (short tags), case-insensitive, possibly with leading whitespace
+        if (!/^<\?/i.test(trimmed)) return false;
+    }
+    if (ext === '.js' && /^[\u4e00-\u9fff]/.test(trimmed)) return false; // starts with CJK char → prose
+    // Reject if the content is overwhelmingly prose (no curly braces / semicolons / keywords)
+    const codeIndicators = (text.match(/[{};]|function |class |const |let |var |require\(|module\.exports|<\?php/gi) || []).length;
+    const lines = text.split('\n').length;
+    if (lines > 5 && codeIndicators === 0) return false;
+    return true;
+}
+
+function buildPrompt(plan, stepIndex, currentLog, currentContent) {
+    return promptManager.getCoderPrompt(plan, stepIndex, currentLog, currentContent);
+}
+
+async function executeStep(task, stepIndex, writeToDisk = false) {
+    const plan = task.plan;
+    const step = plan.steps[stepIndex];
+    const action = String(step.action || '').toLowerCase();
+    if (!['modify', 'create'].includes(action)) {
+        return {
+            logEntry: {
+                step: stepIndex + 1,
+                file: step.file || '',
+                status: 'skipped',
+                reason: `Action "${step.action || ''}" is not a coding action`,
+                timestamp: new Date().toISOString()
+            },
+            newContent: ''
+        };
+    }
+
+    let file = step.file;
+    if (Array.isArray(file)) {
+        console.warn(`[Coder] Warning: step.file is an array. Using first element.`, file);
+        file = file[0];
+    }
+    file = file ? String(file).trim() : '';
+    if (!file) {
+        throw new Error(`[Coder] Missing target file for ${action} step`);
+    }
+
+    const cwd = getProjectCWD();
+    let filePath;
+    try {
+        filePath = enforceBoundary(cwd, file);
+    } catch (err) {
+        throw new Error(`[Coder] Path validation failed: ${err.message}`);
+    }
+    console.log(`[Coder] Targeting file: ${filePath} (workspace: ${cwd})`);
+
+    // Read current content if modifying, checking in-memory proposed changes first
+    let currentContent = '';
+    const relPath = path.relative(cwd, filePath).replace(/\\/g, '/');
+    if (task.proposed_changes && task.proposed_changes[relPath] !== undefined) {
+        currentContent = task.proposed_changes[relPath];
+    } else if (fs.existsSync(filePath)) {
+        const stat = fs.statSync(filePath);
+        if (!stat.isFile()) {
+            throw new Error(`[Coder] Target path is not a file: ${file}`);
+        }
+        currentContent = fs.readFileSync(filePath, 'utf8');
+    }
+
+    // Build prompt (include current content inline for gemini-flash non-interactive mode)
+    const prompt = buildPrompt(plan, stepIndex, task.coding_log, currentContent);
+    // Use flash — pro triggers interactive agent mode via stdin (exits with code null)
+    const response = await runGemini(prompt, 'gemini-2.5-flash');
+
+    // Extract code block — prefer language-specific fence, fall back to any fence
+    const lang = langTag(file);
+    // Group 1: everything after the optional lang tag on the opening fence line, up to closing ```
+    const langPattern = lang ? new RegExp('```' + lang + '[^\\n]*\\n([\\s\\S]*?)\\n?```', 'i') : null;
+    // Fallback: any fenced block — skip the first line (lang tag), capture the rest
+    const fallbackPattern = /```[^\n]*\n([\s\S]*?)\n?```/;
+    const codeMatch = (langPattern && response.match(langPattern))
+        || response.match(fallbackPattern);
+    // If no fence found at all, use the raw response as a last resort
+    const newContent = codeMatch ? codeMatch[1] : response;
+
+    // Safety guard: refuse to write AI prose / markdown chat responses as code
+    if (!looksLikeCode(newContent, file)) {
+        throw new Error(
+            `[Coder] Extracted content for "${file}" does not look like source code. ` +
+            `Refusing to overwrite. AI may have returned chat text instead of code.`
+        );
+    }
+
+    // Write file back
+    if (writeToDisk) fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    if (writeToDisk) fs.writeFileSync(filePath, newContent, 'utf8');
+
+    // Update log
+    const logEntry = {
+        step: stepIndex + 1,
+        file: step.file,
+        status: 'done',
+        lines_changed: newContent.split('\n').length,
+        timestamp: new Date().toISOString()
+    };
+    
+    return { logEntry, newContent };
+}
+
+module.exports = { executeStep };