scalix 0.0.1 → 1.1.0

package/dist/plugins.js

@@ -0,0 +1,132 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { z } from 'zod';
+import { PROJECT_CONFIG_DIR, PLUGIN_DEFAULTS } from './constants.js';
+const PLUGINS_DIR = `${PROJECT_CONFIG_DIR}/plugins`;
+const manifestSchema = z.object({
+    name: z.string(),
+    version: z.string().default('1.0.0'),
+    description: z.string().default(''),
+    tools: z.array(z.object({
+        name: z.string(),
+        description: z.string(),
+        inputSchema: z.record(z.string(), z.unknown()).default({}),
+        handler: z.string(),
+    })),
+    permissions: z.object({
+        allowedTools: z.array(z.string()).optional(),
+        blockedTools: z.array(z.string()).optional(),
+        permissionMode: z.enum(['plan', 'default', 'auto']).optional(),
+    }).optional(),
+});
+let _pluginCache = new Map();
+const CACHE_TTL_MS = PLUGIN_DEFAULTS.cacheTtlMs;
+async function loadPluginHandler(pluginDir, handlerPath) {
+    const fullPath = path.resolve(pluginDir, handlerPath);
+    const normalizedFull = path.normalize(fullPath);
+    const normalizedDir = path.normalize(pluginDir) + path.sep;
+    if (!normalizedFull.startsWith(normalizedDir)) {
+        throw new Error(`Plugin handler path escapes plugin directory: ${handlerPath}`);
+    }
+    try {
+        await fs.access(fullPath);
+    }
+    catch {
+        throw new Error(`Plugin handler not found: ${fullPath}`);
+    }
+    const fileUrl = pathToFileURL(fullPath).href;
+    const mod = await import(fileUrl);
+    if (typeof mod.default === 'function')
+        return mod.default;
+    if (typeof mod.execute === 'function')
+        return mod.execute;
+    if (typeof mod.handler === 'function')
+        return mod.handler;
+    throw new Error(`Plugin handler ${handlerPath} must export default, execute, or handler function`);
+}
+export async function loadPlugin(pluginDir) {
+    const manifestPath = path.join(pluginDir, 'plugin.json');
+    try {
+        await fs.access(manifestPath);
+    }
+    catch {
+        return null;
+    }
+    try {
+        const raw = await fs.readFile(manifestPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const manifest = manifestSchema.parse(parsed);
+        const tools = [];
+        for (const toolDef of manifest.tools) {
+            try {
+                const handler = await loadPluginHandler(pluginDir, toolDef.handler);
+                tools.push({
+                    type: 'function',
+                    function: {
+                        name: `plugin_${manifest.name}_${toolDef.name}`,
+                        description: `[Plugin: ${manifest.name}] ${toolDef.description}`,
+                        parameters: toolDef.inputSchema,
+                        execute: handler,
+                    },
+                });
+            }
+            catch (err) {
+                process.stderr.write(`Warning: failed to load plugin tool ${toolDef.name}: ${err.message}\n`);
+            }
+        }
+        return { manifest, tools, path: pluginDir };
+    }
+    catch (err) {
+        process.stderr.write(`Warning: failed to load plugin from ${pluginDir}: ${err.message}\n`);
+        return null;
+    }
+}
+export async function discoverPlugins(projectRoot) {
+    const cached = _pluginCache.get(projectRoot);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+        return cached.plugins;
+    }
+    const pluginsDir = path.join(projectRoot, PLUGINS_DIR);
+    const plugins = [];
+    try {
+        await fs.access(pluginsDir);
+    }
+    catch {
+        return [];
+    }
+    try {
+        const entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const pluginDir = path.join(pluginsDir, entry.name);
+            const plugin = await loadPlugin(pluginDir);
+            if (plugin)
+                plugins.push(plugin);
+        }
+        const rootPlugin = await loadPlugin(pluginsDir);
+        if (rootPlugin)
+            plugins.push(rootPlugin);
+    }
+    catch {
+        return [];
+    }
+    _pluginCache.set(projectRoot, { plugins, timestamp: Date.now() });
+    return plugins;
+}
+export function getPluginTools(plugins) {
+    return plugins.flatMap((p) => p.tools);
+}
+export function pluginsSummary(plugins) {
+    if (plugins.length === 0)
+        return 'No plugins loaded.';
+    const lines = [`${plugins.length} plugin(s) loaded:`];
+    for (const p of plugins) {
+        lines.push(`  ${p.manifest.name} v${p.manifest.version} (${p.tools.length} tools)`);
+        for (const t of p.tools) {
+            lines.push(`    - ${t.function.name}: ${t.function.description}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/project-index.js

@@ -0,0 +1,376 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import fg from 'fast-glob';
+import { PROJECT_INDEX_DEFAULTS } from './constants.js';
+const IGNORE_DIRS = [
+    'node_modules', '.git', 'dist', 'build', 'out', '.next', '.nuxt',
+    '.cache', 'coverage', '.turbo', '.vercel', '.svelte-kit', '__pycache__',
+    'venv', '.venv', 'target', 'vendor',
+];
+const CODE_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py', '.rb', '.go', '.rs', '.java', '.kt', '.swift',
+    '.c', '.cpp', '.h', '.hpp', '.cs', '.php',
+    '.vue', '.svelte', '.astro',
+    '.sql', '.graphql', '.gql',
+    '.sh', '.bash', '.zsh',
+]);
+const CONFIG_FILES = new Set([
+    'package.json', 'tsconfig.json', 'pyproject.toml', 'Cargo.toml',
+    'go.mod', 'Gemfile', 'pom.xml', 'build.gradle', 'Makefile',
+    'docker-compose.yml', 'Dockerfile', '.env.example',
+]);
+// JS/TS patterns
+const JS_SYMBOL_PATTERNS = [
+    { kind: 'function', pattern: /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/gm },
+    { kind: 'class', pattern: /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/gm },
+    { kind: 'interface', pattern: /^(?:export\s+)?interface\s+(\w+)/gm },
+    { kind: 'type', pattern: /^(?:export\s+)?type\s+(\w+)\s*[=<]/gm },
+    { kind: 'export', pattern: /^export\s+(?:default\s+)?(?:const|let|var|function|class)\s+(\w+)/gm },
+    { kind: 'const', pattern: /^(?:export\s+)?const\s+(\w+)\s*[:=]/gm },
+];
+// Python patterns
+const PY_SYMBOL_PATTERNS = [
+    { kind: 'function', pattern: /^(?:async\s+)?def\s+(\w+)\s*\(/gm },
+    { kind: 'class', pattern: /^class\s+(\w+)[\s(:]/gm },
+    { kind: 'variable', pattern: /^(\w+)\s*(?::\s*\w+)?\s*=/gm },
+];
+// Go patterns
+const GO_SYMBOL_PATTERNS = [
+    { kind: 'function', pattern: /^func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/gm },
+    { kind: 'type', pattern: /^type\s+(\w+)\s+(?:struct|interface)\b/gm },
+    { kind: 'const', pattern: /^(?:var|const)\s+(\w+)\s/gm },
+];
+// Rust patterns
+const RS_SYMBOL_PATTERNS = [
+    { kind: 'function', pattern: /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/gm },
+    { kind: 'type', pattern: /^(?:pub\s+)?struct\s+(\w+)/gm },
+    { kind: 'type', pattern: /^(?:pub\s+)?enum\s+(\w+)/gm },
+    { kind: 'interface', pattern: /^(?:pub\s+)?trait\s+(\w+)/gm },
+    { kind: 'type', pattern: /^impl(?:<[^>]+>)?\s+(\w+)/gm },
+];
+// Java/Kotlin patterns
+const JAVA_SYMBOL_PATTERNS = [
+    { kind: 'class', pattern: /^(?:public\s+)?(?:abstract\s+)?(?:final\s+)?class\s+(\w+)/gm },
+    { kind: 'interface', pattern: /^(?:public\s+)?interface\s+(\w+)/gm },
+    { kind: 'function', pattern: /^\s+(?:public|private|protected|static|\s)*\s+\w+\s+(\w+)\s*\(/gm },
+    { kind: 'type', pattern: /^(?:public\s+)?enum\s+(\w+)/gm },
+];
+// Ruby patterns
+const RB_SYMBOL_PATTERNS = [
+    { kind: 'function', pattern: /^\s*def\s+(?:self\.)?(\w+)/gm },
+    { kind: 'class', pattern: /^\s*class\s+(\w+)/gm },
+    { kind: 'type', pattern: /^\s*module\s+(\w+)/gm },
+];
+// PHP patterns
+const PHP_SYMBOL_PATTERNS = [
+    { kind: 'function', pattern: /^(?:public|private|protected|static|\s)*\s*function\s+(\w+)/gm },
+    { kind: 'class', pattern: /^(?:abstract\s+)?class\s+(\w+)/gm },
+    { kind: 'interface', pattern: /^interface\s+(\w+)/gm },
+    { kind: 'interface', pattern: /^trait\s+(\w+)/gm },
+];
+const LANGUAGE_PATTERNS = {
+    '.ts': JS_SYMBOL_PATTERNS,
+    '.tsx': JS_SYMBOL_PATTERNS,
+    '.js': JS_SYMBOL_PATTERNS,
+    '.jsx': JS_SYMBOL_PATTERNS,
+    '.mjs': JS_SYMBOL_PATTERNS,
+    '.cjs': JS_SYMBOL_PATTERNS,
+    '.py': PY_SYMBOL_PATTERNS,
+    '.go': GO_SYMBOL_PATTERNS,
+    '.rs': RS_SYMBOL_PATTERNS,
+    '.java': JAVA_SYMBOL_PATTERNS,
+    '.kt': JAVA_SYMBOL_PATTERNS,
+    '.rb': RB_SYMBOL_PATTERNS,
+    '.php': PHP_SYMBOL_PATTERNS,
+    '.swift': JAVA_SYMBOL_PATTERNS,
+    '.cs': JAVA_SYMBOL_PATTERNS,
+    '.c': GO_SYMBOL_PATTERNS,
+    '.cpp': GO_SYMBOL_PATTERNS,
+    '.h': GO_SYMBOL_PATTERNS,
+    '.hpp': GO_SYMBOL_PATTERNS,
+};
+function detectTechStack(files) {
+    const stack = [];
+    const names = new Set(files.map((f) => path.basename(f.relativePath)));
+    const exts = new Set(files.map((f) => f.ext));
+    if (names.has('package.json'))
+        stack.push('Node.js');
+    if (names.has('tsconfig.json') || exts.has('.ts') || exts.has('.tsx'))
+        stack.push('TypeScript');
+    if (exts.has('.jsx') || exts.has('.tsx'))
+        stack.push('React');
+    if (names.has('next.config.js') || names.has('next.config.mjs') || names.has('next.config.ts'))
+        stack.push('Next.js');
+    if (names.has('nuxt.config.ts') || names.has('nuxt.config.js'))
+        stack.push('Nuxt');
+    if (exts.has('.vue'))
+        stack.push('Vue');
+    if (exts.has('.svelte'))
+        stack.push('Svelte');
+    if (names.has('pyproject.toml') || names.has('setup.py') || exts.has('.py'))
+        stack.push('Python');
+    if (names.has('Cargo.toml') || exts.has('.rs'))
+        stack.push('Rust');
+    if (names.has('go.mod') || exts.has('.go'))
+        stack.push('Go');
+    if (names.has('Gemfile') || exts.has('.rb'))
+        stack.push('Ruby');
+    if (names.has('pom.xml') || names.has('build.gradle') || exts.has('.java'))
+        stack.push('Java');
+    if (exts.has('.kt'))
+        stack.push('Kotlin');
+    if (exts.has('.swift'))
+        stack.push('Swift');
+    if (names.has('Dockerfile') || names.has('docker-compose.yml'))
+        stack.push('Docker');
+    if (names.has('.github'))
+        stack.push('GitHub Actions');
+    if (names.has('tailwind.config.js') || names.has('tailwind.config.ts'))
+        stack.push('Tailwind CSS');
+    if (names.has('prisma'))
+        stack.push('Prisma');
+    if (names.has('drizzle.config.ts'))
+        stack.push('Drizzle');
+    return stack;
+}
+function buildTree(files, maxDepth = 3) {
+    const dirs = new Map();
+    for (const f of files) {
+        const parts = f.relativePath.split('/');
+        if (parts.length > maxDepth + 1)
+            continue;
+        const dir = parts.length === 1 ? '.' : parts.slice(0, -1).join('/');
+        if (!dirs.has(dir))
+            dirs.set(dir, []);
+        dirs.get(dir).push(parts[parts.length - 1]);
+    }
+    const lines = [];
+    const sortedDirs = [...dirs.keys()].sort();
+    for (const dir of sortedDirs) {
+        const depth = dir === '.' ? 0 : dir.split('/').length;
+        const indent = '  '.repeat(depth);
+        if (dir !== '.') {
+            const dirName = dir.split('/').pop();
+            lines.push(`${indent}${dirName}/`);
+        }
+        const fileIndent = '  '.repeat(depth + (dir === '.' ? 0 : 1));
+        const dirFiles = dirs.get(dir).sort();
+        if (dirFiles.length <= PROJECT_INDEX_DEFAULTS.treeDisplayLimit) {
+            for (const file of dirFiles) {
+                lines.push(`${fileIndent}${file}`);
+            }
+        }
+        else {
+            for (const file of dirFiles.slice(0, PROJECT_INDEX_DEFAULTS.treeDisplayTruncate)) {
+                lines.push(`${fileIndent}${file}`);
+            }
+            lines.push(`${fileIndent}... and ${dirFiles.length - PROJECT_INDEX_DEFAULTS.treeDisplayTruncate} more files`);
+        }
+    }
+    return lines.join('\n');
+}
+async function extractSymbols(filePath, relativePath) {
+    const ext = path.extname(filePath);
+    if (!CODE_EXTENSIONS.has(ext))
+        return [];
+    const patterns = LANGUAGE_PATTERNS[ext];
+    if (!patterns)
+        return [];
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        if (content.length > PROJECT_INDEX_DEFAULTS.symbolParseMaxChars)
+            return [];
+        const symbols = [];
+        for (const { kind, pattern } of patterns) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(content)) !== null) {
+                const name = match[1];
+                if (!name || name.length < 2)
+                    continue;
+                if (/^(if|for|while|switch|return|import|from|const|let|var|self|this|else|elif|case|catch|try)$/.test(name))
+                    continue;
+                const lineNum = content.substring(0, match.index).split('\n').length;
+                if (symbols.some((s) => s.name === name && s.kind === kind && s.file === relativePath))
+                    continue;
+                symbols.push({ name, kind, file: relativePath, line: lineNum });
+            }
+        }
+        return symbols;
+    }
+    catch {
+        return [];
+    }
+}
+// Import patterns for dependency tracking
+const IMPORT_PATTERNS = [
+    // JS/TS: import { x } from './y' or import x from './y' or require('./y')
+    { ext: new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']),
+        pattern: /(?:import\s+(?:{([^}]+)}\s+from\s+|(\w+)\s+from\s+)?['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g },
+    // Python: from x import y or import x
+    { ext: new Set(['.py']),
+        pattern: /(?:from\s+([\w.]+)\s+import\s+([\w,\s*]+)|import\s+([\w.]+))/g },
+    // Go: import "x" or import ( "x" )
+    { ext: new Set(['.go']),
+        pattern: /import\s+(?:(?:\w+\s+)?"([^"]+)"|[\s\S]*?"([^"]+)")/g },
+    // Rust: use x::y
+    { ext: new Set(['.rs']),
+        pattern: /use\s+([\w:]+(?:::\{[^}]+\})?)/g },
+];
+function extractImports(content, relativePath, ext) {
+    const imports = [];
+    for (const { ext: exts, pattern } of IMPORT_PATTERNS) {
+        if (!exts.has(ext))
+            continue;
+        const regex = new RegExp(pattern.source, pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const modulePath = match[3] || match[4] || match[1] || match[5] || match[6] || '';
+            if (!modulePath)
+                continue;
+            // Only track local imports (starting with . or relative paths)
+            const isLocal = modulePath.startsWith('.') || modulePath.startsWith('/');
+            if (!isLocal)
+                continue;
+            const importedSymbols = (match[1] || match[2] || '').split(',').map((s) => s.trim().split(/\s+as\s+/)[0]).filter(Boolean);
+            imports.push({
+                from: relativePath,
+                to: modulePath,
+                symbols: importedSymbols,
+            });
+        }
+    }
+    return imports;
+}
+async function buildProjectIndexFresh(root) {
+    const ignorePattern = IGNORE_DIRS.map((d) => `**/${d}/**`);
+    const globbed = await fg('**/*', {
+        cwd: root,
+        ignore: ignorePattern,
+        onlyFiles: true,
+        stats: true,
+        dot: false,
+        followSymbolicLinks: false,
+        suppressErrors: true,
+    });
+    const files = [];
+    for (const entry of globbed) {
+        const stats = entry.stats;
+        if (!stats || stats.size > PROJECT_INDEX_DEFAULTS.maxFileSizeBytes)
+            continue;
+        files.push({
+            path: path.join(root, entry.path),
+            relativePath: entry.path,
+            size: stats.size,
+            ext: path.extname(entry.path),
+            modifiedAt: stats.mtimeMs,
+        });
+    }
+    files.sort((a, b) => b.modifiedAt - a.modifiedAt);
+    const codeFiles = files.filter((f) => CODE_EXTENSIONS.has(f.ext));
+    const symbolFiles = codeFiles.slice(0, PROJECT_INDEX_DEFAULTS.symbolFileLimit);
+    // Extract symbols and imports in batches to avoid OOM on huge repos
+    const BATCH_SIZE = 50;
+    const allImports = [];
+    const symbols = [];
+    for (let i = 0; i < symbolFiles.length; i += BATCH_SIZE) {
+        const batch = symbolFiles.slice(i, i + BATCH_SIZE);
+        const batchResults = await Promise.all(batch.map(async (f) => {
+            if (f.size > PROJECT_INDEX_DEFAULTS.symbolParseMaxChars)
+                return [];
+            const content = await fs.readFile(f.path, 'utf-8').catch(() => '');
+            if (!content)
+                return [];
+            const fileImports = extractImports(content, f.relativePath, f.ext);
+            allImports.push(...fileImports);
+            return extractSymbols(f.path, f.relativePath);
+        }));
+        symbols.push(...batchResults.flat());
+    }
+    const techStack = detectTechStack(files);
+    const tree = buildTree(files);
+    const totalFiles = files.length;
+    const totalCode = codeFiles.length;
+    const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+    const sizeMB = (totalSize / 1_000_000).toFixed(1);
+    const summary = [
+        `Project: ${path.basename(root)}`,
+        `Files: ${totalFiles} total, ${totalCode} code files (${sizeMB} MB)`,
+        `Tech: ${techStack.join(', ') || 'Unknown'}`,
+        `Symbols: ${symbols.length} (${symbols.filter((s) => s.kind === 'function').length} functions, ${symbols.filter((s) => s.kind === 'class').length} classes, ${symbols.filter((s) => s.kind === 'interface').length} interfaces)`,
+        `Imports: ${allImports.length} local dependencies tracked`,
+    ].join('\n');
+    return {
+        root,
+        files,
+        symbols,
+        imports: allImports,
+        tree,
+        techStack,
+        summary,
+        indexedAt: Date.now(),
+    };
+}
+const INDEX_CACHE_FILE = '.scalix/project-index.json';
+const INDEX_CACHE_MAX_AGE_MS = 10 * 60 * 1000; // 10 minutes
+export async function loadCachedIndex(root) {
+    try {
+        const cachePath = path.join(root, INDEX_CACHE_FILE);
+        const raw = await fs.readFile(cachePath, 'utf-8');
+        const cached = JSON.parse(raw);
+        if (Date.now() - cached.indexedAt < INDEX_CACHE_MAX_AGE_MS) {
+            return cached;
+        }
+    }
+    catch { }
+    return null;
+}
+async function saveCachedIndex(root, index) {
+    try {
+        const cacheDir = path.join(root, '.scalix');
+        await fs.mkdir(cacheDir, { recursive: true });
+        const cachePath = path.join(root, INDEX_CACHE_FILE);
+        await fs.writeFile(cachePath, JSON.stringify(index), 'utf-8');
+    }
+    catch { }
+}
+export async function buildProjectIndex(root, forceRefresh = false) {
+    if (!forceRefresh) {
+        const cached = await loadCachedIndex(root);
+        if (cached)
+            return cached;
+    }
+    const index = await buildProjectIndexFresh(root);
+    await saveCachedIndex(root, index);
+    return index;
+}
+export function indexToContext(index) {
+    const topSymbols = index.symbols.slice(0, 100);
+    const symbolList = topSymbols
+        .map((s) => `  ${s.kind} ${s.name} (${s.file}:${s.line})`)
+        .join('\n');
+    // Build dependency graph summary: most-imported files
+    const importCounts = new Map();
+    for (const imp of index.imports) {
+        importCounts.set(imp.to, (importCounts.get(imp.to) ?? 0) + 1);
+    }
+    const topDeps = [...importCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 20)
+        .map(([dep, count]) => `  ${dep} (imported by ${count} files)`)
+        .join('\n');
+    return [
+        '## Project Overview',
+        index.summary,
+        '',
+        '## File Tree',
+        index.tree,
+        '',
+        '## Key Symbols',
+        symbolList || '  (no symbols extracted)',
+        '',
+        '## Key Dependencies',
+        topDeps || '  (no local imports tracked)',
+    ].join('\n');
+}

package/dist/project-memory.js

@@ -0,0 +1,165 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { PROJECT_CONFIG_DIR } from './constants.js';
+const SCALIX_DIR = PROJECT_CONFIG_DIR;
+const MEMORY_FILE = 'memory.json';
+function emptyMemory() {
+    return {
+        conventions: [],
+        patterns: [],
+        notes: [],
+        lastUpdated: new Date().toISOString(),
+    };
+}
+function memoryPath(projectRoot) {
+    return path.join(projectRoot, SCALIX_DIR, MEMORY_FILE);
+}
+async function ensureDir(projectRoot) {
+    await fs.mkdir(path.join(projectRoot, SCALIX_DIR), { recursive: true });
+}
+export async function loadMemory(projectRoot) {
+    try {
+        const raw = await fs.readFile(memoryPath(projectRoot), 'utf-8');
+        const parsed = JSON.parse(raw);
+        return { ...emptyMemory(), ...parsed };
+    }
+    catch {
+        return { ...emptyMemory() };
+    }
+}
+export async function saveMemory(projectRoot, memory) {
+    await ensureDir(projectRoot);
+    memory.lastUpdated = new Date().toISOString();
+    await fs.writeFile(memoryPath(projectRoot), JSON.stringify(memory, null, 2), 'utf-8');
+}
+export async function addConvention(projectRoot, key, value, source = 'user') {
+    const memory = await loadMemory(projectRoot);
+    const existing = memory.conventions.findIndex((c) => c.key === key);
+    if (existing >= 0) {
+        memory.conventions[existing] = { key, value, source };
+    }
+    else {
+        memory.conventions.push({ key, value, source });
+    }
+    await saveMemory(projectRoot, memory);
+}
+export async function addPattern(projectRoot, pattern) {
+    const memory = await loadMemory(projectRoot);
+    const existing = memory.patterns.findIndex((p) => p.name === pattern.name);
+    if (existing >= 0) {
+        memory.patterns[existing] = pattern;
+    }
+    else {
+        memory.patterns.push(pattern);
+    }
+    await saveMemory(projectRoot, memory);
+}
+export async function addNote(projectRoot, note) {
+    const trimmed = note.trim();
+    if (!trimmed)
+        return;
+    const memory = await loadMemory(projectRoot);
+    if (!memory.notes.some((n) => n.toLowerCase() === trimmed.toLowerCase())) {
+        memory.notes.push(trimmed);
+        if (memory.notes.length > 200)
+            memory.notes = memory.notes.slice(-200);
+        await saveMemory(projectRoot, memory);
+    }
+}
+const CORRECTION_PATTERNS = [
+    /^no[,.]?\s+(don'?t|do not|never|stop|avoid|please don'?t)\s+/i,
+    /^(don'?t|do not|never|stop|avoid)\s+/i,
+    /^(always|make sure|remember to)\s+(?:use|avoid|check|ensure|handle|validate|include|add|run)\s+/i,
+    /^(use|prefer)\s+\S+\s+(instead|over|not)\s+/i,
+];
+export function detectCorrection(message) {
+    const trimmed = message.trim().split('\n')[0];
+    if (trimmed.length < 8 || trimmed.length > 200)
+        return null;
+    for (const p of CORRECTION_PATTERNS) {
+        if (p.test(trimmed))
+            return trimmed;
+    }
+    return null;
+}
+export async function autoDetectConventions(projectRoot) {
+    const conventions = [];
+    try {
+        const pkg = JSON.parse(await fs.readFile(path.join(projectRoot, 'package.json'), 'utf-8'));
+        if (pkg.type === 'module')
+            conventions.push({ key: 'module_system', value: 'ESM', source: 'auto' });
+        else
+            conventions.push({ key: 'module_system', value: 'CommonJS', source: 'auto' });
+        if (pkg.scripts?.test)
+            conventions.push({ key: 'test_command', value: pkg.scripts.test, source: 'auto' });
+        if (pkg.scripts?.lint)
+            conventions.push({ key: 'lint_command', value: pkg.scripts.lint, source: 'auto' });
+        if (pkg.scripts?.build)
+            conventions.push({ key: 'build_command', value: pkg.scripts.build, source: 'auto' });
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps.prettier)
+            conventions.push({ key: 'formatter', value: 'Prettier', source: 'auto' });
+        if (deps.eslint)
+            conventions.push({ key: 'linter', value: 'ESLint', source: 'auto' });
+        if (deps.vitest)
+            conventions.push({ key: 'test_framework', value: 'Vitest', source: 'auto' });
+        if (deps.jest)
+            conventions.push({ key: 'test_framework', value: 'Jest', source: 'auto' });
+        if (deps.mocha)
+            conventions.push({ key: 'test_framework', value: 'Mocha', source: 'auto' });
+        if (deps.tailwindcss)
+            conventions.push({ key: 'css_framework', value: 'Tailwind CSS', source: 'auto' });
+        if (deps.prisma || deps['@prisma/client'])
+            conventions.push({ key: 'orm', value: 'Prisma', source: 'auto' });
+        if (deps.drizzle)
+            conventions.push({ key: 'orm', value: 'Drizzle', source: 'auto' });
+    }
+    catch { }
+    try {
+        const tsconfig = JSON.parse(await fs.readFile(path.join(projectRoot, 'tsconfig.json'), 'utf-8'));
+        if (tsconfig.compilerOptions?.strict)
+            conventions.push({ key: 'typescript_strict', value: 'true', source: 'auto' });
+        if (tsconfig.compilerOptions?.target)
+            conventions.push({ key: 'ts_target', value: tsconfig.compilerOptions.target, source: 'auto' });
+    }
+    catch { }
+    try {
+        await fs.access(path.join(projectRoot, '.prettierrc'));
+        conventions.push({ key: 'has_prettier_config', value: 'true', source: 'auto' });
+    }
+    catch { }
+    try {
+        const gitignore = await fs.readFile(path.join(projectRoot, '.gitignore'), 'utf-8');
+        if (gitignore.includes('.env'))
+            conventions.push({ key: 'env_files_ignored', value: 'true', source: 'auto' });
+    }
+    catch { }
+    return conventions;
+}
+export function memoryToContext(memory) {
+    const lines = ['## Project Memory'];
+    if (memory.conventions.length > 0) {
+        lines.push('');
+        lines.push('### Conventions');
+        for (const c of memory.conventions) {
+            lines.push(`  ${c.key}: ${c.value}`);
+        }
+    }
+    if (memory.patterns.length > 0) {
+        lines.push('');
+        lines.push('### Patterns');
+        for (const p of memory.patterns) {
+            lines.push(`  ${p.name}: ${p.description}`);
+            if (p.example)
+                lines.push(`    Example: ${p.example}`);
+        }
+    }
+    if (memory.notes.length > 0) {
+        lines.push('');
+        lines.push('### Notes');
+        for (const n of memory.notes.slice(-10)) {
+            lines.push(`  - ${n}`);
+        }
+    }
+    return lines.join('\n');
+}