codelocal 1.5.0-beta.1

package/dist/semantic.js

@@ -0,0 +1,263 @@
+import ts from "typescript";
+import path from "node:path";
+import { readdirSync } from "node:fs";
+const SKIP_DIRS = new Set([".git", "node_modules", ".next", "dist", "build", "target", ".venv", "venv", "coverage", ".cache", ".turbo", ".dart_tool", "Pods", "DerivedData"]);
+function rel(root, file) {
+    return path.relative(path.resolve(root), path.resolve(file)).split(path.sep).join("/") || ".";
+}
+function inside(root, file) {
+    const relative = path.relative(path.resolve(root), path.resolve(file));
+    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+}
+function isNodeModules(root, file) {
+    const relative = rel(root, file);
+    return relative === "node_modules" || relative.startsWith("node_modules/") || relative.includes("/node_modules/");
+}
+function pos(source, node) {
+    const p = source.getLineAndCharacterOfPosition(node.getStart(source));
+    return { line: p.line + 1, column: p.character + 1 };
+}
+function nodeName(node) {
+    const anyNode = node;
+    return anyNode.name;
+}
+function kindName(node) {
+    return ts.SyntaxKind[node.kind] ?? "Unknown";
+}
+function discoverConfigs(root, maxDepth, maxProjects) {
+    const out = [];
+    const walk = (dir, depth) => {
+        if (depth > maxDepth || out.length >= maxProjects)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        const names = new Set(entries.map((entry) => entry.name));
+        for (const candidate of ["tsconfig.json", "jsconfig.json"]) {
+            if (names.has(candidate)) {
+                out.push(path.join(dir, candidate));
+                if (out.length >= maxProjects)
+                    return;
+            }
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || SKIP_DIRS.has(entry.name))
+                continue;
+            walk(path.join(dir, entry.name), depth + 1);
+            if (out.length >= maxProjects)
+                return;
+        }
+    };
+    walk(root, 0);
+    return out.sort((a, b) => {
+        const da = rel(root, a).split("/").length;
+        const db = rel(root, b).split("/").length;
+        return da - db || a.localeCompare(b);
+    });
+}
+export class TypeScriptSemanticIndex {
+    root;
+    projects = [];
+    configPaths = [];
+    builtAt = 0;
+    attempted = false;
+    constructor(root) {
+        this.root = root;
+    }
+    invalidate() {
+        this.projects = [];
+        this.configPaths = [];
+        this.builtAt = 0;
+        this.attempted = false;
+    }
+    build() {
+        if (this.attempted)
+            return;
+        this.attempted = true;
+        const maxProjects = Math.max(1, Number(process.env.CODELOCAL_TS_MAX_PROJECTS ?? 20) || 20);
+        const maxDepth = Math.max(1, Number(process.env.CODELOCAL_TS_CONFIG_DEPTH ?? 6) || 6);
+        const maxFilesPerProject = Math.max(100, Number(process.env.CODELOCAL_TS_MAX_FILES_PER_PROJECT ?? 4_000) || 4_000);
+        const maxTotalFiles = Math.max(maxFilesPerProject, Number(process.env.CODELOCAL_TS_MAX_TOTAL_FILES ?? 12_000) || 12_000);
+        const configs = discoverConfigs(this.root, maxDepth, maxProjects);
+        let remaining = maxTotalFiles;
+        for (const config of configs) {
+            if (remaining <= 0)
+                break;
+            const read = ts.readConfigFile(config, ts.sys.readFile);
+            if (read.error)
+                continue;
+            const parsed = ts.parseJsonConfigFileContent(read.config ?? {}, ts.sys, path.dirname(config));
+            const rootNames = parsed.fileNames.slice(0, Math.min(maxFilesPerProject, remaining));
+            if (!rootNames.length)
+                continue;
+            remaining -= rootNames.length;
+            const options = { ...parsed.options, noEmit: true, skipLibCheck: true };
+            try {
+                const program = ts.createProgram({ rootNames, options });
+                this.projects.push({ configPath: config, program, checker: program.getTypeChecker() });
+                this.configPaths.push(config);
+            }
+            catch { }
+        }
+        this.builtAt = Date.now();
+    }
+    info() {
+        this.build();
+        return {
+            available: this.projects.length > 0,
+            configured: this.configPaths.length > 0,
+            mode: this.projects.length > 1 ? "typescript-multi-project" : this.projects.length === 1 ? "typescript-program" : "fallback",
+            configPath: this.configPaths[0] ? rel(this.root, this.configPaths[0]) : null,
+            configPaths: this.configPaths.map((config) => rel(this.root, config)),
+            projectCount: this.projects.length,
+            sourceFiles: this.projectSources().length,
+            builtAt: this.builtAt,
+        };
+    }
+    projectSources() {
+        this.build();
+        const unique = new Map();
+        for (const project of this.projects) {
+            for (const source of project.program.getSourceFiles()) {
+                if (!inside(this.root, source.fileName))
+                    continue;
+                if (isNodeModules(this.root, source.fileName))
+                    continue;
+                unique.set(path.resolve(source.fileName), source);
+            }
+        }
+        return [...unique.values()];
+    }
+    workspaceSymbols(query = "", limit = 200) {
+        const q = query.toLowerCase();
+        const out = [];
+        for (const source of this.projectSources()) {
+            const visit = (node) => {
+                const name = nodeName(node);
+                if (name && (ts.isIdentifier(name) || ts.isStringLiteral(name))) {
+                    const n = name.text;
+                    if (!q || n.toLowerCase().includes(q)) {
+                        out.push({ path: rel(this.root, source.fileName), ...pos(source, name), kind: kindName(node), name: n });
+                        if (out.length >= limit)
+                            return;
+                    }
+                }
+                if (out.length < limit)
+                    ts.forEachChild(node, visit);
+            };
+            visit(source);
+            if (out.length >= limit)
+                break;
+        }
+        return out;
+    }
+    definitions(name, limit = 100) {
+        return this.workspaceSymbols(name, limit).filter((x) => x.name === name);
+    }
+    references(name, limit = 500) {
+        const out = [];
+        for (const source of this.projectSources()) {
+            const visit = (node) => {
+                if (ts.isIdentifier(node) && node.text === name) {
+                    out.push({ path: rel(this.root, source.fileName), ...pos(source, node), kind: kindName(node.parent), name });
+                }
+                if (out.length < limit)
+                    ts.forEachChild(node, visit);
+            };
+            visit(source);
+            if (out.length >= limit)
+                break;
+        }
+        return out;
+    }
+    callers(name, limit = 300) {
+        const out = [];
+        for (const source of this.projectSources()) {
+            const stack = [];
+            const visit = (node) => {
+                stack.push(node);
+                if (ts.isCallExpression(node)) {
+                    const expression = node.expression;
+                    const called = ts.isIdentifier(expression) ? expression.text : ts.isPropertyAccessExpression(expression) ? expression.name.text : null;
+                    if (called === name) {
+                        const owner = stack.slice(0, -1).reverse().find((n) => ts.isFunctionDeclaration(n) || ts.isMethodDeclaration(n) || ts.isArrowFunction(n) || ts.isFunctionExpression(n));
+                        const ownerName = owner ? nodeName(owner) : undefined;
+                        out.push({ path: rel(this.root, source.fileName), ...pos(source, node), kind: "CallExpression", name: ownerName && ts.isIdentifier(ownerName) ? ownerName.text : undefined });
+                    }
+                }
+                if (out.length < limit)
+                    ts.forEachChild(node, visit);
+                stack.pop();
+            };
+            visit(source);
+            if (out.length >= limit)
+                break;
+        }
+        return out;
+    }
+    callees(name, limit = 300) {
+        const out = [];
+        for (const source of this.projectSources()) {
+            const visit = (node, insideOwner = false) => {
+                const n = nodeName(node);
+                const matchesOwner = !!n && ts.isIdentifier(n) && n.text === name && (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isFunctionExpression(node));
+                const nextInside = insideOwner || matchesOwner;
+                if (nextInside && ts.isCallExpression(node)) {
+                    const expression = node.expression;
+                    const called = ts.isIdentifier(expression) ? expression.text : ts.isPropertyAccessExpression(expression) ? expression.name.text : null;
+                    if (called)
+                        out.push({ path: rel(this.root, source.fileName), ...pos(source, node), kind: "CallExpression", name: called });
+                }
+                if (out.length < limit)
+                    ts.forEachChild(node, (child) => visit(child, nextInside));
+            };
+            visit(source, false);
+            if (out.length >= limit)
+                break;
+        }
+        return out;
+    }
+    importGraph(limit = 2000) {
+        const edges = [];
+        for (const source of this.projectSources()) {
+            for (const statement of source.statements) {
+                if (ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement)) {
+                    const spec = statement.moduleSpecifier;
+                    if (spec && ts.isStringLiteral(spec))
+                        edges.push({ from: rel(this.root, source.fileName), to: spec.text, kind: ts.isImportDeclaration(statement) ? "import" : "export" });
+                }
+            }
+            if (edges.length >= limit)
+                break;
+        }
+        return edges.slice(0, limit);
+    }
+    diagnostics(limit = 500) {
+        this.build();
+        const out = [];
+        const seen = new Set();
+        for (const project of this.projects) {
+            for (const d of ts.getPreEmitDiagnostics(project.program)) {
+                const message = ts.flattenDiagnosticMessageText(d.messageText, "\n");
+                const file = d.file?.fileName;
+                const key = `${file ?? ""}:${d.start ?? -1}:${d.code}:${message}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                if (!d.file || d.start == null)
+                    out.push({ message, code: d.code, category: ts.DiagnosticCategory[d.category] });
+                else {
+                    const p = d.file.getLineAndCharacterOfPosition(d.start);
+                    out.push({ path: rel(this.root, d.file.fileName), line: p.line + 1, column: p.character + 1, message, code: d.code, category: ts.DiagnosticCategory[d.category] });
+                }
+                if (out.length >= limit)
+                    return out;
+            }
+        }
+        return out;
+    }
+}

package/dist/state.js

@@ -0,0 +1,110 @@
+import { mkdir, open, readFile, rename, unlink, chmod, appendFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import os from "node:os";
+import { randomUUID } from "node:crypto";
+export const DEFAULT_STATE_DIR = process.env.CODELOCAL_STATE_DIR ?? join(os.homedir(), ".codelocal");
+export async function ensurePrivateDir(dir = DEFAULT_STATE_DIR) {
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    if (process.platform !== "win32")
+        await chmod(dir, 0o700).catch(() => undefined);
+    return dir;
+}
+export async function readJsonFile(file, fallback) {
+    try {
+        return JSON.parse(await readFile(file, "utf8"));
+    }
+    catch {
+        return fallback;
+    }
+}
+export async function writeJsonAtomic(file, value) {
+    const parent = dirname(file);
+    await ensurePrivateDir(parent);
+    const temp = join(parent, `.${randomUUID()}.tmp`);
+    let created = false;
+    try {
+        const handle = await open(temp, "wx", 0o600);
+        created = true;
+        try {
+            if (process.platform !== "win32")
+                await handle.chmod(0o600).catch(() => undefined);
+            await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`, "utf8");
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temp, file);
+        created = false;
+        if (process.platform !== "win32")
+            await chmod(file, 0o600).catch(() => undefined);
+    }
+    finally {
+        if (created)
+            await unlink(temp).catch(() => undefined);
+    }
+}
+export async function appendPrivateJsonl(file, value) {
+    await ensurePrivateDir(dirname(file));
+    await appendFile(file, `${JSON.stringify(value)}\n`, { encoding: "utf8", mode: 0o600 });
+    if (process.platform !== "win32")
+        await chmod(file, 0o600).catch(() => undefined);
+}
+export class IdempotencyJournal {
+    file;
+    maxEntries;
+    map = new Map();
+    loaded = false;
+    constructor(file = join(DEFAULT_STATE_DIR, "journal.json"), maxEntries = 1000) {
+        this.file = file;
+        this.maxEntries = maxEntries;
+    }
+    async load() {
+        if (this.loaded)
+            return;
+        const entries = await readJsonFile(this.file, []);
+        for (const entry of entries)
+            this.map.set(entry.key, entry);
+        this.loaded = true;
+    }
+    async get(key) {
+        await this.load();
+        return this.map.get(key) ?? null;
+    }
+    async start(key, operation) {
+        await this.load();
+        const existing = this.map.get(key);
+        if (existing)
+            return existing;
+        const entry = { key, operation, startedAt: Date.now(), status: "started" };
+        this.map.set(key, entry);
+        await this.flush();
+        return entry;
+    }
+    async complete(key, result) {
+        await this.load();
+        const entry = this.map.get(key);
+        if (!entry)
+            return;
+        entry.status = "completed";
+        entry.completedAt = Date.now();
+        entry.result = result;
+        delete entry.error;
+        await this.flush();
+    }
+    async fail(key, error) {
+        await this.load();
+        const entry = this.map.get(key);
+        if (!entry)
+            return;
+        entry.status = "failed";
+        entry.completedAt = Date.now();
+        entry.error = error;
+        await this.flush();
+    }
+    async flush() {
+        const values = [...this.map.values()].sort((a, b) => b.startedAt - a.startedAt).slice(0, this.maxEntries);
+        this.map = new Map(values.map((x) => [x.key, x]));
+        await writeJsonAtomic(this.file, values);
+    }
+}

package/dist/terminal-history.js

@@ -0,0 +1,102 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { appendPrivateJsonl, DEFAULT_STATE_DIR } from "./state.js";
+import { redactCommand } from "./security-policy.js";
+export class TerminalHistory {
+    file;
+    starts = new Map();
+    constructor(file = process.env.CODELOCAL_TERMINAL_HISTORY_PATH ?? path.join(DEFAULT_STATE_DIR, "terminal-history.jsonl")) {
+        this.file = file;
+    }
+    async started(input) {
+        const record = {
+            ts: new Date().toISOString(),
+            event: "started",
+            workspaceKey: input.workspaceKey,
+            processId: input.processId,
+            requestId: input.requestId,
+            sessionId: input.sessionId,
+            cwd: input.cwd,
+            command: redactCommand(input.command).slice(0, 4000),
+            riskLevel: input.riskLevel,
+            matchedRules: input.matchedRules,
+            approval: input.approval,
+            startedAt: input.startedAt,
+            executionMode: input.executionMode,
+        };
+        this.starts.set(record.processId, record);
+        await appendPrivateJsonl(this.file, record);
+        return record;
+    }
+    async finished(record) {
+        const start = this.starts.get(record.processId);
+        const finishedAt = Date.now();
+        const output = {
+            ts: new Date().toISOString(),
+            event: "finished",
+            workspaceKey: record.workspaceKey,
+            processId: record.processId,
+            requestId: start?.requestId,
+            sessionId: start?.sessionId,
+            cwd: start?.cwd ?? record.cwd,
+            command: start?.command ?? redactCommand(record.command).slice(0, 4000),
+            riskLevel: start?.riskLevel ?? "UNKNOWN",
+            matchedRules: start?.matchedRules ?? [],
+            approval: start?.approval ?? "automatic",
+            startedAt: record.startedAt,
+            finishedAt,
+            durationMs: Math.max(0, finishedAt - record.startedAt),
+            exitCode: record.exitCode,
+            status: record.status,
+            executionMode: record.executionMode,
+        };
+        this.starts.delete(record.processId);
+        await appendPrivateJsonl(this.file, output);
+        return output;
+    }
+    async tail(maxBytes = 4 * 1024 * 1024) {
+        let handle = null;
+        try {
+            handle = await fs.open(this.file, "r");
+            const stat = await handle.stat();
+            const length = Math.min(stat.size, maxBytes);
+            const buffer = Buffer.alloc(length);
+            await handle.read(buffer, 0, length, Math.max(0, stat.size - length));
+            let text = buffer.toString("utf8");
+            if (stat.size > length)
+                text = text.slice(text.indexOf("\n") + 1);
+            return text;
+        }
+        catch {
+            return "";
+        }
+        finally {
+            await handle?.close().catch(() => undefined);
+        }
+    }
+    async query(options = {}) {
+        const raw = await this.tail();
+        const query = String(options.query ?? "").trim().toLowerCase();
+        const event = options.event ?? "started";
+        const limit = Math.max(1, Math.min(Number(options.limit ?? 50), 500));
+        const records = [];
+        for (const line of raw.split(/\r?\n/).reverse()) {
+            if (!line.trim())
+                continue;
+            try {
+                const record = JSON.parse(line);
+                if (options.workspaceKey && record.workspaceKey !== options.workspaceKey)
+                    continue;
+                if (event !== "all" && record.event !== event)
+                    continue;
+                if (query && !`${record.command} ${record.cwd} ${record.riskLevel} ${record.status ?? ""}`.toLowerCase().includes(query))
+                    continue;
+                records.push(record);
+                if (records.length >= limit)
+                    break;
+            }
+            catch { }
+        }
+        return { records, truncatedByReadWindow: Buffer.byteLength(raw, "utf8") >= 4 * 1024 * 1024 };
+    }
+}

package/dist/verification.js

@@ -0,0 +1,66 @@
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+function diagnosticKey(d) {
+    return `${d.path ?? ""}:${d.line ?? 0}:${d.column ?? 0}:${d.code ?? ""}:${d.message ?? ""}`;
+}
+async function gitDiff(root) {
+    return new Promise((resolve) => {
+        const child = spawn("git", ["diff", "--no-ext-diff", "--unified=2"], { cwd: root, stdio: ["ignore", "pipe", "pipe"] });
+        let output = "";
+        child.stdout.on("data", (d) => { output = (output + d.toString()).slice(-1_500_000); });
+        child.stderr.on("data", (d) => { output = (output + d.toString()).slice(-1_500_000); });
+        child.on("error", () => resolve(""));
+        child.on("close", () => resolve(output));
+    });
+}
+export class VerificationEngine {
+    root;
+    semantic;
+    context;
+    snapshots = new Map();
+    constructor(root, semantic, context) {
+        this.root = root;
+        this.semantic = semantic;
+        this.context = context;
+    }
+    async snapshotDiagnostics(paths = []) {
+        const diagnostics = [];
+        if (paths.length) {
+            for (const p of [...new Set(paths)])
+                diagnostics.push(...await this.semantic.diagnostics(p, 500));
+        }
+        else
+            diagnostics.push(...await this.semantic.diagnostics(undefined, 1000));
+        const snapshotId = randomUUID();
+        this.snapshots.set(snapshotId, diagnostics);
+        if (this.snapshots.size > 30)
+            this.snapshots.delete(this.snapshots.keys().next().value);
+        return { snapshotId, diagnostics };
+    }
+    compare(baselineId, currentDiagnostics) {
+        const baseline = this.snapshots.get(baselineId);
+        if (!baseline)
+            throw new Error("Unknown diagnostic baseline.");
+        const before = new Map(baseline.map((d) => [diagnosticKey(d), d]));
+        const after = new Map(currentDiagnostics.map((d) => [diagnosticKey(d), d]));
+        return {
+            new: [...after.entries()].filter(([k]) => !before.has(k)).map(([, d]) => d),
+            persisting: [...after.entries()].filter(([k]) => before.has(k)).map(([, d]) => d),
+            resolved: [...before.entries()].filter(([k]) => !after.has(k)).map(([, d]) => d),
+        };
+    }
+    async verify(paths = [], baselineId) {
+        const current = await this.snapshotDiagnostics(paths);
+        const project = await this.context.map();
+        const diff = await gitDiff(this.root);
+        const checks = [...project.typecheckCommands, ...project.lintCommands, ...project.testCommands].slice(0, 8);
+        return {
+            diagnostics: current.diagnostics,
+            diagnosticSnapshotId: current.snapshotId,
+            regression: baselineId ? this.compare(baselineId, current.diagnostics) : null,
+            recommendedChecks: checks,
+            diff: diff.slice(-1_000_000),
+            diffTruncated: diff.length > 1_000_000,
+        };
+    }
+}