salmon-loop 0.2.3

package/dist/core/plan/markdown-editor.js

@@ -0,0 +1,238 @@
+import { randomBytes } from 'crypto';
+const STEP_ID_RE = /^[a-zA-Z0-9_.:-]{3,128}$/;
+export function assertValidStepId(stepId) {
+    if (!STEP_ID_RE.test(stepId)) {
+        throw new Error('Invalid stepId.');
+        // test
+    }
+}
+const toCheckboxChar = (state) => (state === 'checked' ? 'x' : ' ');
+const fromCheckboxChar = (raw) => raw.toLowerCase() === 'x' ? 'checked' : 'unchecked';
+export function generateStepId(prefix = 'stp') {
+    return `${prefix}_${randomBytes(6).toString('hex')}`;
+}
+function updateCheckboxOnLine(line, checkbox) {
+    if (!checkbox)
+        return line;
+    const re = /(-\s*)\[( |x|X)\]/;
+    const match = line.match(re);
+    if (!match)
+        return line;
+    return line.replace(re, `$1[${toCheckboxChar(checkbox)}]`);
+}
+function updateStatusInComment(line, status) {
+    if (!status)
+        return { line, ok: true };
+    const open = '<!--';
+    const close = '-->';
+    // Find the metadata comment containing sl:id=...
+    let idx = 0;
+    while (idx < line.length) {
+        const start = line.indexOf(open, idx);
+        if (start === -1)
+            break;
+        const end = line.indexOf(close, start + open.length);
+        if (end === -1)
+            return { line, ok: false };
+        const comment = line.slice(start, end + close.length);
+        if (!comment.includes('sl:id=')) {
+            idx = end + close.length;
+            continue;
+        }
+        const key = 'sl:status=';
+        if (comment.includes(key)) {
+            const keyIdx = comment.indexOf(key);
+            const valueStart = keyIdx + key.length;
+            let valueEnd = valueStart;
+            while (valueEnd < comment.length) {
+                const ch = comment[valueEnd];
+                if (ch === ' ' || ch === '\t' || ch === '\r' || ch === '\n' || ch === '-')
+                    break;
+                if (comment.startsWith(close, valueEnd))
+                    break;
+                valueEnd++;
+            }
+            const replaced = comment.slice(0, valueStart) + status + comment.slice(valueEnd);
+            const nextLine = line.slice(0, start) + replaced + line.slice(end + close.length);
+            return { line: nextLine, ok: true };
+        }
+        // Insert status before -->
+        const beforeClose = comment.slice(0, comment.length - close.length);
+        const trimmed = beforeClose.endsWith(' ') ? beforeClose : `${beforeClose} `;
+        const injected = `${trimmed}sl:status=${status} ${close}`;
+        const nextLine = line.slice(0, start) + injected + line.slice(end + close.length);
+        return { line: nextLine, ok: true };
+    }
+    return { line, ok: false };
+}
+function extractIndent(line) {
+    const m = line.match(/^(\s*)/);
+    return m ? m[1] : '';
+}
+function ensureConflictsSection(lines) {
+    const headingPrefix = '## ⚠️ Conflicts';
+    let idx = lines.findIndex((l) => l.trim().startsWith(headingPrefix));
+    if (idx !== -1)
+        return idx;
+    if (lines.length > 0 && lines[lines.length - 1].trim() !== '')
+        lines.push('');
+    idx = lines.length;
+    lines.push('## ⚠️ Conflicts (Auto-generated)');
+    lines.push('- (empty)');
+    return idx;
+}
+function appendConflict(lines, message) {
+    const idx = ensureConflictsSection(lines);
+    // Replace placeholder if it's still empty.
+    if (lines[idx + 1] && lines[idx + 1].trim() === '- (empty)') {
+        lines[idx + 1] = `- ${message}`;
+        return;
+    }
+    lines.splice(idx + 1, 0, `- ${message}`);
+}
+export function appendPlanConflictOnly(raw, params) {
+    const lines = raw.split('\n');
+    appendConflict(lines, params.message);
+    if (params.note && params.note.trim()) {
+        appendFieldNote(lines, params.note.trim(), params.now);
+    }
+    return lines.join('\n');
+}
+function appendFieldNote(lines, note, now) {
+    const headingRe = /^##\s+/;
+    const heading = '## 📝 Field Notes (Reflections)';
+    let idx = lines.findIndex((l) => l.trim() === heading);
+    if (idx === -1) {
+        if (lines.length > 0 && lines[lines.length - 1].trim() !== '')
+            lines.push('');
+        idx = lines.length;
+        lines.push(heading);
+    }
+    // Insert before next heading, or at EOF.
+    let insertAt = idx + 1;
+    while (insertAt < lines.length && !headingRe.test(lines[insertAt]))
+        insertAt++;
+    const stamp = now.toISOString().slice(0, 16).replace('T', ' ');
+    lines.splice(insertAt, 0, `- *${stamp}*: ${note}`);
+}
+export function appendPlanNoteOnly(raw, params) {
+    const lines = raw.split('\n');
+    appendFieldNote(lines, params.note, params.now);
+    return lines.join('\n');
+}
+function parseStatusFromLine(line) {
+    const m = line.match(/sl:status=([a-zA-Z_]+)/);
+    if (!m)
+        return 'todo';
+    const raw = m[1];
+    switch (raw) {
+        case 'todo':
+        case 'active':
+        case 'done':
+        case 'failed':
+        case 'skipped':
+        case 'conflict':
+            return raw;
+        default:
+            return 'todo';
+    }
+}
+function parseCheckboxFromLine(line) {
+    const m = line.match(/-\s*\[( |x|X)\]/);
+    if (!m)
+        return 'unchecked';
+    return fromCheckboxChar(m[1]);
+}
+function parseTextFromLine(line) {
+    // Strip leading "- [ ]" and trailing metadata comment (if any)
+    const stripped = line.replace(/^\s*-\s*\[(?: |x|X)\]\s*/, '');
+    return stripped.replace(/\s*<!--[\s\S]*?-->\s*$/, '').trim();
+}
+function parseStepIdFromLine(line) {
+    const m = line.match(/sl:id=([a-zA-Z0-9_.:-]+)/);
+    return m?.[1] ?? null;
+}
+export function applyPlanUpdate(raw, params) {
+    const { stepId, patch, now } = params;
+    assertValidStepId(stepId);
+    const lines = raw.split('\n');
+    const idx = lines.findIndex((l) => l.includes(`sl:id=${stepId}`));
+    if (idx === -1) {
+        appendConflict(lines, `STEP_NOT_FOUND: sl:id=${stepId}`);
+        return { ok: false, content: lines.join('\n'), error: 'STEP_NOT_FOUND' };
+    }
+    let line = lines[idx];
+    line = updateCheckboxOnLine(line, patch.checkbox);
+    const statusRes = updateStatusInComment(line, patch.status);
+    if (!statusRes.ok) {
+        appendConflict(lines, `MALFORMED_METADATA: sl:id=${stepId}`);
+        return { ok: false, content: lines.join('\n'), error: 'MALFORMED_METADATA' };
+    }
+    line = statusRes.line;
+    lines[idx] = line;
+    if (patch.appendSubtasks && patch.appendSubtasks.length > 0) {
+        const parentIndent = extractIndent(lines[idx]);
+        let subIndent = `${parentIndent}  `;
+        // Detect existing subtask indentation style (first immediate child list item)
+        for (let i = idx + 1; i < lines.length; i++) {
+            const next = lines[i];
+            if (next.trim() === '')
+                continue;
+            const nextIndent = extractIndent(next);
+            if (nextIndent.length <= parentIndent.length)
+                break;
+            if (/^\s*-\s*\[( |x|X)\]/.test(next)) {
+                subIndent = nextIndent;
+                break;
+            }
+        }
+        // Insert after the last child line belonging to this step (block with deeper indent)
+        let insertAt = idx + 1;
+        while (insertAt < lines.length) {
+            const next = lines[insertAt];
+            if (next.trim() === '') {
+                insertAt++;
+                continue;
+            }
+            const nextIndent = extractIndent(next);
+            if (nextIndent.length <= parentIndent.length)
+                break;
+            insertAt++;
+        }
+        const newLines = patch.appendSubtasks.map((t) => {
+            const id = generateStepId(`${stepId}`);
+            return `${subIndent}- [ ] ${t} <!-- sl:id=${id} -->`;
+        });
+        lines.splice(insertAt, 0, ...newLines);
+    }
+    if (typeof patch.note === 'string' && patch.note.trim()) {
+        appendFieldNote(lines, patch.note.trim(), now);
+    }
+    return { ok: true, content: lines.join('\n') };
+}
+export function summarizePlan(raw, limits) {
+    const maxActive = limits?.maxActive ?? 8;
+    const maxPending = limits?.maxPending ?? 12;
+    const lines = raw.split('\n');
+    const steps = lines
+        .filter((l) => l.includes('sl:id=') && /^\s*-\s*\[( |x|X)\]/.test(l))
+        .map((l) => {
+        const stepId = parseStepIdFromLine(l);
+        if (!stepId)
+            return null;
+        return {
+            stepId,
+            text: parseTextFromLine(l),
+            checkbox: parseCheckboxFromLine(l),
+            status: parseStatusFromLine(l),
+        };
+    })
+        .filter(Boolean);
+    const active = steps.filter((s) => s.status === 'active').slice(0, maxActive);
+    const pending = steps.filter((s) => s.status === 'todo').slice(0, maxPending);
+    const recentDone = steps.filter((s) => s.checkbox === 'checked' || s.status === 'done').slice(-3);
+    const conflictsHeading = lines.findIndex((l) => l.trim().startsWith('## ⚠️ Conflicts'));
+    const conflicts = { present: conflictsHeading !== -1 };
+    return { active, pending, recentDone, conflicts };
+}
+//# sourceMappingURL=markdown-editor.js.map

package/dist/core/plan/storage.js

@@ -0,0 +1,75 @@
+import { randomBytes, createHash } from 'crypto';
+import path from 'path';
+import { mkdir, readFile, rename, stat, writeFile } from '../adapters/fs/node-fs.js';
+const SESSION_ID_RE = /^[a-zA-Z0-9_-]{6,64}$/;
+export function assertValidSessionId(sessionId) {
+    if (!SESSION_ID_RE.test(sessionId)) {
+        throw new Error('Invalid sessionId (expected 6-64 chars of [a-zA-Z0-9_-]).');
+    }
+}
+export function resolvePlanFilePath(params) {
+    const { persistenceRoot, sessionId } = params;
+    assertValidSessionId(sessionId);
+    const planDir = path.resolve(persistenceRoot, '.salmonloop', 'plans', sessionId);
+    const planFile = path.join(planDir, 'SALMONLOOP_PLAN.md');
+    const planFileRelHint = path.posix.join('.salmonloop', 'plans', sessionId, 'SALMONLOOP_PLAN.md');
+    return { planDir, planFile, planFileRelHint };
+}
+export async function readPlanFile(planFile) {
+    return readFile(planFile, 'utf-8');
+}
+export async function writePlanFileAtomic(planDir, planFile, content) {
+    await mkdir(planDir, { recursive: true });
+    const tmp = path.join(planDir, `.tmp-${process.pid}-${randomBytes(6).toString('hex')}.md`);
+    await writeFile(tmp, content, 'utf-8');
+    await rename(tmp, planFile);
+}
+async function resolveGitDir(repoRoot) {
+    const dotGit = path.join(repoRoot, '.git');
+    try {
+        const st = await stat(dotGit);
+        if (st.isDirectory())
+            return dotGit;
+    }
+    catch {
+        // ignore
+    }
+    try {
+        const raw = await readFile(dotGit, 'utf-8');
+        const line = raw.split('\n')[0] ?? '';
+        const m = line.match(/^gitdir:\s*(.+)\s*$/);
+        if (!m)
+            return null;
+        const gitdir = m[1].trim();
+        return path.isAbsolute(gitdir) ? gitdir : path.resolve(repoRoot, gitdir);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Ensure `.salmonloop/` is ignored locally so runtime artifacts do not dirty user repos.
+ * Uses `.git/info/exclude` (local-only) rather than modifying tracked `.gitignore`.
+ */
+export async function ensureSalmonloopIgnored(repoRoot) {
+    const gitDir = await resolveGitDir(repoRoot);
+    if (!gitDir)
+        return;
+    const excludePath = path.join(gitDir, 'info', 'exclude');
+    await mkdir(path.dirname(excludePath), { recursive: true });
+    let existing = '';
+    try {
+        existing = await readFile(excludePath, 'utf-8');
+    }
+    catch {
+        existing = '';
+    }
+    if (existing.split('\n').some((l) => l.trim() === '.salmonloop/'))
+        return;
+    const next = `${existing.replace(/\s*$/, '')}\n.salmonloop/\n`;
+    await writeFile(excludePath, next, 'utf-8');
+}
+export function sha256(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+//# sourceMappingURL=storage.js.map

package/dist/core/plan/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/plugin/interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=interface.js.map

package/dist/core/plugin/loader.js

@@ -0,0 +1,130 @@
+import { join } from 'path';
+import { typescriptPlugin, tsxPlugin, javascriptPlugin } from '../../languages/typescript/index.js';
+import { readdir } from '../adapters/fs/node-fs.js';
+import { getLogger } from '../observability/logger.js';
+import { validateQueryPack } from './validator.js';
+// Import built-in plugins (Phase 1: explicit import)
+export class PluginLoader {
+    static loaded = new WeakSet();
+    /**
+     * Initialize and load all available plugins.
+     * This should be called early in the application startup (e.g., Preflight).
+     *
+     * @param repoPath - Optional repository path to scan for user plugins
+     */
+    static async loadPlugins(registry, repoPath) {
+        if (this.loaded.has(registry))
+            return;
+        try {
+            // Phase 1: Manually register TypeScript/JavaScript plugins
+            getLogger().debug('Loading built-in plugins...');
+            this.registerWithValidation(registry, typescriptPlugin);
+            this.registerWithValidation(registry, tsxPlugin);
+            this.registerWithValidation(registry, javascriptPlugin);
+            getLogger().debug(`Plugins loaded: ${typescriptPlugin.meta.name}, ${tsxPlugin.meta.name}, ${javascriptPlugin.meta.name}`);
+            // Phase 2: Load user plugins from .salmonloop/languages/
+            if (repoPath) {
+                await this.loadUserPlugins(registry, repoPath);
+            }
+            this.loaded.add(registry);
+        }
+        catch (error) {
+            // In test environment, we want to know why it failed
+            if (process.env.NODE_ENV === 'test') {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                getLogger().error(`CRITICAL: Failed to load plugins: ${errorMsg}`);
+                throw error;
+            }
+            getLogger().error(`Failed to load plugins: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Scan and load user plugins from .salmonloop/languages/
+     */
+    static async loadUserPlugins(registry, repoPath) {
+        const userPluginDir = join(repoPath, '.salmonloop', 'languages');
+        try {
+            // Check if directory exists
+            const entries = await readdir(userPluginDir, { withFileTypes: true });
+            const pluginDirs = entries
+                .filter((ent) => ent.isDirectory())
+                .map((ent) => ent.name);
+            if (pluginDirs.length === 0)
+                return;
+            getLogger().info(`Found ${pluginDirs.length} potential user plugins in ${userPluginDir}`);
+            for (const dirName of pluginDirs) {
+                const entryPoint = join(userPluginDir, dirName, 'index.js');
+                try {
+                    // Dynamic import (ESM)
+                    // We use file:// protocol for Windows compatibility with absolute paths in import()
+                    const modulePath = process.platform === 'win32' ? `file://${entryPoint}` : entryPoint;
+                    const pluginModule = await import(modulePath);
+                    const plugin = pluginModule.default;
+                    if (this.isValidPlugin(plugin)) {
+                        this.registerWithValidation(registry, plugin);
+                        getLogger().info(`Loaded user plugin: ${plugin.meta.name} (${plugin.meta.id})`);
+                    }
+                    else {
+                        getLogger().warn(`Skipping invalid user plugin in ${dirName}: missing required fields.`);
+                    }
+                }
+                catch (err) {
+                    if (err && typeof err === 'object' && 'code' in err && err.code !== 'ENOENT') {
+                        getLogger().warn(`Failed to load user plugin from ${dirName}: ${err instanceof Error ? (err instanceof Error ? err.message : String(err)) : String(err)}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            // Ignore if directory doesn't exist
+            if (err && typeof err === 'object' && 'code' in err && err.code !== 'ENOENT') {
+                getLogger().debug(`Error scanning for user plugins: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    /**
+     * Reset loader state (useful for testing)
+     */
+    static reset() {
+        this.loaded = new WeakSet();
+    }
+    /**
+     * Runtime validation of the plugin interface (Duck Typing)
+     */
+    static isValidPlugin(obj) {
+        if (!obj || typeof obj !== 'object')
+            return false;
+        // Check Metadata
+        if (!obj.meta || typeof obj.meta.id !== 'string' || !Array.isArray(obj.meta.extensions)) {
+            return false;
+        }
+        // Check Detection
+        if (!obj.detection || typeof obj.detection.matches !== 'function') {
+            return false;
+        }
+        // Check Parsing
+        if (!obj.parsing || typeof obj.parsing.getTreeSitterWasm !== 'function') {
+            return false;
+        }
+        // Check Dependency
+        if (!obj.dependency || typeof obj.dependency.extractImports !== 'function') {
+            return false;
+        }
+        // Check Diagnostics
+        if (!obj.diagnostics || typeof obj.diagnostics.classifyError !== 'function') {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Register plugin with queryPack validation
+     */
+    static registerWithValidation(registry, plugin) {
+        const validation = validateQueryPack(plugin);
+        if (!validation.valid) {
+            getLogger().warn(`Plugin ${plugin.meta.id} has queryPack validation errors: ${validation.errors.join(', ')}`);
+        }
+        registry.register(plugin);
+    }
+}
+//# sourceMappingURL=loader.js.map

package/dist/core/plugin/registry.js

@@ -0,0 +1,90 @@
+import { getLogger } from '../observability/logger.js';
+export class PluginRegistry {
+    plugins = new Map();
+    extensionMap = new Map();
+    changeListeners = [];
+    /**
+     * Register a new language plugin
+     */
+    register(plugin) {
+        if (this.plugins.has(plugin.meta.id)) {
+            getLogger().warn(`Plugin ${plugin.meta.id} is already registered. Overwriting.`);
+        }
+        this.plugins.set(plugin.meta.id, plugin);
+        // Map extensions to this plugin for quick lookup
+        for (const ext of plugin.meta.extensions) {
+            // normalize extension to start with dot
+            const normalizedExt = ext.startsWith('.') ? ext : `.${ext}`;
+            this.extensionMap.set(normalizedExt, plugin);
+        }
+        this.emitChange();
+    }
+    /**
+     * Get all registered plugins
+     */
+    getAll() {
+        return Array.from(this.plugins.values());
+    }
+    onChange(listener) {
+        this.changeListeners.push(listener);
+        return () => {
+            this.changeListeners = this.changeListeners.filter((l) => l !== listener);
+        };
+    }
+    emitChange() {
+        for (const listener of this.changeListeners) {
+            listener();
+        }
+    }
+    /**
+     * Get plugin by ID
+     */
+    getById(id) {
+        return this.plugins.get(id);
+    }
+    /**
+     * Get plugin by file extension
+     */
+    getByExtension(filepath) {
+        // Extract extension from filepath (e.g., 'src/main.ts' -> '.ts')
+        // Simple extraction, can be improved
+        const match = filepath.match(/(\.[^.]+)$/);
+        if (!match)
+            return undefined;
+        const ext = match[1];
+        return this.extensionMap.get(ext);
+    }
+    /**
+     * Detect language for a repository
+     */
+    async detectLanguage(repoPath) {
+        // Sort plugins? Maybe by some priority if added later.
+        // For now, return the first match.
+        for (const plugin of this.plugins.values()) {
+            if (await plugin.detection.matches(repoPath)) {
+                return plugin;
+            }
+        }
+        return undefined;
+    }
+}
+export function createPluginRegistry() {
+    return new PluginRegistry();
+}
+let activePluginRegistry = null;
+export function setPluginRegistry(registry) {
+    activePluginRegistry = registry;
+}
+export function getPluginRegistry() {
+    if (!activePluginRegistry) {
+        throw new Error('PluginRegistry is not initialized. Call setPluginRegistry() at startup.');
+    }
+    return activePluginRegistry;
+}
+export function tryGetPluginRegistry() {
+    return activePluginRegistry;
+}
+export function clearPluginRegistry() {
+    activePluginRegistry = null;
+}
+//# sourceMappingURL=registry.js.map

package/dist/core/plugin/validator.js

@@ -0,0 +1,98 @@
+import { getLogger } from '../observability/logger.js';
+/**
+ * Validate queryPack queries at plugin load time.
+ * Checks for:
+ * - Valid tree-sitter query syntax (basic validation)
+ * - Required capture names are present
+ * - Version compatibility (if specified)
+ */
+export function validateQueryPack(plugin) {
+    const errors = [];
+    const queryPack = plugin.parsing.queryPack;
+    if (!queryPack) {
+        return { valid: true, errors: [] };
+    }
+    // Validate version (if present)
+    if (queryPack.version) {
+        const version = queryPack.version;
+        if (!/^\d+\.\d+\.\d+$/.test(version)) {
+            errors.push(`queryPack version must follow semver format (e.g., '1.0.0'), got: ${version}`);
+        }
+    }
+    // Validate symbols.calls query
+    if (queryPack.symbols?.calls) {
+        const callsQuery = queryPack.symbols.calls;
+        if (!callsQuery.includes('@callee')) {
+            errors.push('symbols.calls query must include @callee capture');
+        }
+        if (!isValidQuerySyntax(callsQuery)) {
+            errors.push('symbols.calls query has invalid syntax');
+        }
+    }
+    // Validate flow.control query
+    if (queryPack.flow?.control) {
+        const controlQuery = queryPack.flow.control;
+        const requiredCaptures = ['@branch', '@loop', '@async'];
+        for (const capture of requiredCaptures) {
+            if (!controlQuery.includes(capture)) {
+                errors.push(`flow.control query must include ${capture} capture`);
+            }
+        }
+        if (!isValidQuerySyntax(controlQuery)) {
+            errors.push('flow.control query has invalid syntax');
+        }
+    }
+    // Validate flow.exceptions query
+    if (queryPack.flow?.exceptions) {
+        const exceptionsQuery = queryPack.flow.exceptions;
+        const requiredCaptures = ['@trycatch', '@throw', '@catch'];
+        for (const capture of requiredCaptures) {
+            if (!exceptionsQuery.includes(capture)) {
+                errors.push(`flow.exceptions query must include ${capture} capture`);
+            }
+        }
+        if (!isValidQuerySyntax(exceptionsQuery)) {
+            errors.push('flow.exceptions query has invalid syntax');
+        }
+    }
+    if (errors.length > 0) {
+        getLogger().warn(`Plugin ${plugin.meta.id} queryPack validation failed: ${errors.join(', ')}`);
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Basic tree-sitter query syntax validation.
+ * Checks for balanced parentheses and basic structure.
+ */
+function isValidQuerySyntax(query) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < query.length; i++) {
+        const char = query[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (char === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (char === '(') {
+            depth++;
+        }
+        else if (char === ')') {
+            depth--;
+            if (depth < 0)
+                return false;
+        }
+    }
+    return depth === 0 && !inString;
+}
+//# sourceMappingURL=validator.js.map