terry-core 0.1.0

package/dist/repo.js

@@ -0,0 +1,214 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import fg from "fast-glob";
+import { ensureWorkspaceDataDirs, readJsonFile, workspaceDataFile, writeJsonFile } from "./workspace-data.js";
+const INDEX_FILE = "repo-index.json";
+const SEMANTIC_FILE = "semantic-index.json";
+function detectProfile(files) {
+    const has = (name) => files.includes(name);
+    const hasAny = (patterns) => files.some((file) => patterns.some((p) => p.test(file)));
+    let language = "unknown";
+    if (hasAny([/\.ts$/, /\.tsx$/]))
+        language = "typescript";
+    else if (hasAny([/\.js$/, /\.jsx$/]))
+        language = "javascript";
+    else if (hasAny([/\.py$/]))
+        language = "python";
+    else if (hasAny([/\.go$/]))
+        language = "go";
+    let framework = "unknown";
+    if (has("next.config.js") || has("next.config.ts"))
+        framework = "nextjs";
+    else if (has("vite.config.ts") || has("vite.config.js"))
+        framework = "vite";
+    else if (has("angular.json"))
+        framework = "angular";
+    else if (hasAny([/manage\.py$/]))
+        framework = "django";
+    else if (hasAny([/go\.mod$/]))
+        framework = "go-mod";
+    let buildSystem = "unknown";
+    if (hasAny([/turbo\.json$/]))
+        buildSystem = "turbo";
+    else if (hasAny([/nx\.json$/]))
+        buildSystem = "nx";
+    else if (hasAny([/vite\.config\.(ts|js)$/]))
+        buildSystem = "vite";
+    else if (hasAny([/webpack\.config\.(ts|js)$/]))
+        buildSystem = "webpack";
+    let testRunner = "unknown";
+    if (hasAny([/vitest\.config\.(ts|js)$/]))
+        testRunner = "vitest";
+    else if (hasAny([/jest\.config\.(ts|js|mjs|cjs)$/]))
+        testRunner = "jest";
+    else if (hasAny([/pytest\.ini$/, /conftest\.py$/]))
+        testRunner = "pytest";
+    else if (hasAny([/_test\.go$/]))
+        testRunner = "go-test";
+    let packageManager = "unknown";
+    if (has("pnpm-lock.yaml"))
+        packageManager = "pnpm";
+    else if (has("package-lock.json"))
+        packageManager = "npm";
+    else if (has("yarn.lock"))
+        packageManager = "yarn";
+    else if (has("go.mod"))
+        packageManager = "go";
+    else if (has("requirements.txt"))
+        packageManager = "pip";
+    return { language, framework, buildSystem, testRunner, packageManager };
+}
+function fileToNode(file) {
+    return { id: file, path: file, kind: "file" };
+}
+function normalizeImportPath(sourceFile, specifier) {
+    if (!specifier.startsWith("."))
+        return null;
+    const sourceDir = path.posix.dirname(sourceFile.replace(/\\/g, "/"));
+    const base = path.posix.normalize(path.posix.join(sourceDir, specifier));
+    const candidates = [base, `${base}.ts`, `${base}.tsx`, `${base}.js`, `${base}.jsx`, `${base}.py`, `${base}.go`];
+    return candidates;
+}
+function extractImportSpecifiers(filePath, content) {
+    const specs = [];
+    if (/\.(ts|tsx|js|jsx)$/.test(filePath)) {
+        const regex = /\bfrom\s+["']([^"']+)["']|require\(\s*["']([^"']+)["']\s*\)/g;
+        let match = regex.exec(content);
+        while (match) {
+            specs.push((match[1] ?? match[2] ?? "").trim());
+            match = regex.exec(content);
+        }
+    }
+    else if (/\.py$/.test(filePath)) {
+        const regex = /^\s*(?:from\s+([a-zA-Z0-9_\.]+)\s+import|import\s+([a-zA-Z0-9_\.]+))/gm;
+        let match = regex.exec(content);
+        while (match) {
+            specs.push((match[1] ?? match[2] ?? "").trim());
+            match = regex.exec(content);
+        }
+    }
+    return specs.filter(Boolean);
+}
+export async function scanWorkspaceGraph(workspacePath) {
+    await ensureWorkspaceDataDirs(workspacePath);
+    const files = await fg(["**/*"], {
+        cwd: workspacePath,
+        onlyFiles: true,
+        ignore: ["node_modules/**", ".git/**", "dist/**", ".next/**", "coverage/**"]
+    });
+    const nodes = files.map(fileToNode);
+    const fileSet = new Set(files.map((f) => f.replace(/\\/g, "/")));
+    const edges = [];
+    for (const file of files.slice(0, 5000)) {
+        const full = path.join(workspacePath, file);
+        const content = await fs.readFile(full, "utf8").catch(() => "");
+        if (!content)
+            continue;
+        const imports = extractImportSpecifiers(file, content);
+        for (const specifier of imports) {
+            const candidates = normalizeImportPath(file, specifier);
+            if (!candidates)
+                continue;
+            const target = candidates.find((candidate) => fileSet.has(candidate));
+            if (!target)
+                continue;
+            edges.push({ from: file.replace(/\\/g, "/"), to: target, type: "import" });
+        }
+    }
+    const profile = detectProfile(files);
+    const graph = {
+        nodes,
+        edges,
+        metadata: {
+            generatedAt: new Date().toISOString(),
+            workspacePath,
+            profile
+        }
+    };
+    await writeJsonFile(workspaceDataFile(workspacePath, INDEX_FILE), graph);
+    const semantic = await readJsonFile(workspaceDataFile(workspacePath, SEMANTIC_FILE), null);
+    if (!semantic) {
+        await writeJsonFile(workspaceDataFile(workspacePath, SEMANTIC_FILE), {
+            state: "pending",
+            generatedAt: null
+        });
+    }
+    return graph;
+}
+export async function getWorkspaceGraph(workspacePath) {
+    await ensureWorkspaceDataDirs(workspacePath);
+    return readJsonFile(workspaceDataFile(workspacePath, INDEX_FILE), null);
+}
+export function graphToTree(graph) {
+    const lines = [];
+    const grouped = new Map();
+    for (const node of graph.nodes) {
+        const dir = path.posix.dirname(node.path);
+        const current = grouped.get(dir) ?? [];
+        current.push(path.posix.basename(node.path));
+        grouped.set(dir, current);
+    }
+    const dirs = [...grouped.keys()].sort();
+    for (const dir of dirs) {
+        lines.push(dir);
+        const files = grouped.get(dir) ?? [];
+        for (const file of files.sort())
+            lines.push(`  - ${file}`);
+    }
+    return lines.join("\n");
+}
+export function suggestTarget(graph) {
+    if (!graph.nodes.length)
+        return undefined;
+    const inbound = new Map();
+    for (const edge of graph.edges) {
+        inbound.set(edge.to, (inbound.get(edge.to) ?? 0) + 1);
+    }
+    return [...inbound.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
+}
+export async function calculateImpact(workspacePath, target) {
+    const graph = await getWorkspaceGraph(workspacePath);
+    if (!graph) {
+        return {
+            target,
+            affectedFiles: [],
+            confidence: 0,
+            rationale: "No repo index found. Run `terry repo scan` first."
+        };
+    }
+    const norm = target.replace(/\\/g, "/");
+    const candidates = graph.nodes.filter((node) => node.path === norm || node.path.endsWith(norm));
+    const root = candidates[0]?.path;
+    if (!root) {
+        return {
+            target,
+            affectedFiles: [],
+            confidence: 0.2,
+            rationale: "Target not found in graph index."
+        };
+    }
+    const reverse = new Map();
+    for (const edge of graph.edges) {
+        const current = reverse.get(edge.to) ?? [];
+        current.push(edge.from);
+        reverse.set(edge.to, current);
+    }
+    const visited = new Set();
+    const queue = [root];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const refs = reverse.get(current) ?? [];
+        for (const file of refs) {
+            if (!visited.has(file)) {
+                visited.add(file);
+                queue.push(file);
+            }
+        }
+    }
+    return {
+        target: root,
+        affectedFiles: [...visited].sort(),
+        confidence: Math.min(1, 0.4 + visited.size * 0.02),
+        rationale: `Computed reverse dependency traversal from ${root}.`
+    };
+}

package/dist/sandbox.d.ts

@@ -0,0 +1 @@
+export declare function resolveInWorkspace(workspacePath: string, relPath: string): string;

package/dist/sandbox.js

@@ -0,0 +1,9 @@
+import path from "node:path";
+export function resolveInWorkspace(workspacePath, relPath) {
+    const workspace = path.resolve(workspacePath);
+    const resolved = path.resolve(workspace, relPath || ".");
+    if (resolved !== workspace && !resolved.startsWith(`${workspace}${path.sep}`)) {
+        throw new Error("Path escapes workspace sandbox.");
+    }
+    return resolved;
+}

package/dist/sessions.d.ts

@@ -0,0 +1,6 @@
+import type { AgentMode, ExecutionMode, SessionRecord, SessionStep } from "./types.js";
+export declare function startSession(workspacePath: string, task: string, mode: AgentMode, executionMode: ExecutionMode): Promise<SessionRecord>;
+export declare function getSession(workspacePath: string, id: string): Promise<SessionRecord | null>;
+export declare function appendSessionStep(workspacePath: string, id: string, step: SessionStep): Promise<SessionRecord>;
+export declare function finishSession(workspacePath: string, id: string, result: SessionRecord["result"]): Promise<SessionRecord>;
+export declare function listSessions(workspacePath: string, limit?: number): Promise<SessionRecord[]>;

package/dist/sessions.js

@@ -0,0 +1,57 @@
+import path from "node:path";
+import { workspaceHash, workspaceSubdir, writeJsonFile, readJsonFile, listJsonFiles, ensureWorkspaceDataDirs } from "./workspace-data.js";
+function sessionsDir(workspacePath) {
+    return workspaceSubdir(workspacePath, "sessions");
+}
+function sessionPath(workspacePath, sessionId) {
+    return path.join(sessionsDir(workspacePath), `${sessionId}.json`);
+}
+function sessionId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+export async function startSession(workspacePath, task, mode, executionMode) {
+    await ensureWorkspaceDataDirs(workspacePath);
+    const record = {
+        id: sessionId(),
+        workspaceHash: workspaceHash(workspacePath),
+        workspacePath,
+        task,
+        startedAt: new Date().toISOString(),
+        mode,
+        executionMode,
+        steps: []
+    };
+    await writeJsonFile(sessionPath(workspacePath, record.id), record);
+    return record;
+}
+export async function getSession(workspacePath, id) {
+    return readJsonFile(sessionPath(workspacePath, id), null);
+}
+export async function appendSessionStep(workspacePath, id, step) {
+    const session = await getSession(workspacePath, id);
+    if (!session)
+        throw new Error(`Session not found: ${id}`);
+    session.steps.push(step);
+    await writeJsonFile(sessionPath(workspacePath, id), session);
+    return session;
+}
+export async function finishSession(workspacePath, id, result) {
+    const session = await getSession(workspacePath, id);
+    if (!session)
+        throw new Error(`Session not found: ${id}`);
+    session.result = result;
+    session.finishedAt = new Date().toISOString();
+    await writeJsonFile(sessionPath(workspacePath, id), session);
+    return session;
+}
+export async function listSessions(workspacePath, limit = 50) {
+    await ensureWorkspaceDataDirs(workspacePath);
+    const files = await listJsonFiles(sessionsDir(workspacePath));
+    const sessions = [];
+    for (const file of files) {
+        const value = await readJsonFile(path.join(sessionsDir(workspacePath), file), null);
+        if (value)
+            sessions.push(value);
+    }
+    return sessions.sort((a, b) => b.startedAt.localeCompare(a.startedAt)).slice(0, limit);
+}

package/dist/status.d.ts

@@ -0,0 +1,2 @@
+import type { WorkspaceStatus } from "./types.js";
+export declare function getWorkspaceStatus(workspacePath: string): Promise<WorkspaceStatus>;

package/dist/status.js

@@ -0,0 +1,22 @@
+import { getWorkspaceSettings } from "./config.js";
+import { getLastExplanation } from "./explain.js";
+import { listPatchProposals } from "./patches.js";
+import { getWorkspaceGraph, suggestTarget } from "./repo.js";
+export async function getWorkspaceStatus(workspacePath) {
+    const settings = await getWorkspaceSettings(workspacePath);
+    const pending = await listPatchProposals(workspacePath, "pending");
+    const last = await getLastExplanation(workspacePath);
+    const graph = await getWorkspaceGraph(workspacePath);
+    return {
+        workspacePath,
+        mode: settings.mode,
+        executionMode: settings.executionMode,
+        pendingPatchCount: pending.length,
+        unresolvedApprovals: pending.reduce((count, proposal) => count + proposal.hunks.filter((hunk) => !hunk.approved).length, 0),
+        lastActionAt: last?.timestamp,
+        lastSummary: last?.summary,
+        repoProfile: graph?.metadata.profile,
+        repoIndexFreshAt: graph?.metadata.generatedAt,
+        nextSuggestedTarget: graph ? suggestTarget(graph) : undefined
+    };
+}

package/dist/templates.d.ts

@@ -0,0 +1,7 @@
+export type TemplateDefinition = {
+    name: string;
+    description: string;
+    prompts: string[];
+};
+export declare function listTemplates(): TemplateDefinition[];
+export declare function getTemplate(name: string): TemplateDefinition | undefined;

package/dist/templates.js

@@ -0,0 +1,44 @@
+const BUILTIN_TEMPLATES = [
+    {
+        name: "add-feature",
+        description: "Scaffold and implement a new feature with tests and docs updates.",
+        prompts: [
+            "Scan this repository and identify where a new feature should be added.",
+            "Implement the feature with minimal regressions and include tests.",
+            "Summarize changed files and migration notes."
+        ]
+    },
+    {
+        name: "add-tests",
+        description: "Identify missing tests and add targeted coverage.",
+        prompts: [
+            "Find critical paths lacking test coverage.",
+            "Add tests for the highest-risk path first.",
+            "Summarize test coverage changes and remaining gaps."
+        ]
+    },
+    {
+        name: "refactor-module",
+        description: "Refactor a module while preserving external behavior.",
+        prompts: [
+            "Analyze module boundaries and propose a safe refactor plan.",
+            "Apply the refactor with minimal API changes.",
+            "Validate with tests and summarize behavioral invariants."
+        ]
+    },
+    {
+        name: "upgrade-dependency",
+        description: "Safely upgrade dependencies and verify compatibility.",
+        prompts: [
+            "List outdated dependencies and rank upgrade risk.",
+            "Upgrade the selected dependency with changelog-aware updates.",
+            "Run checks and summarize compatibility impact."
+        ]
+    }
+];
+export function listTemplates() {
+    return BUILTIN_TEMPLATES;
+}
+export function getTemplate(name) {
+    return BUILTIN_TEMPLATES.find((template) => template.name === name);
+}

package/dist/tools.d.ts

@@ -0,0 +1,7 @@
+import type { ToolArgsMap, ToolName, ToolResult, WorkspaceSettings } from "./types.js";
+type ToolContext = {
+    workspacePath: string;
+    settings: WorkspaceSettings;
+};
+export declare function executeTool<T extends ToolName>(context: ToolContext, tool: T, args: ToolArgsMap[T]): Promise<ToolResult>;
+export {};

package/dist/tools.js

@@ -0,0 +1,148 @@
+import fs from "node:fs/promises";
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+import fg from "fast-glob";
+import { resolveInWorkspace } from "./sandbox.js";
+import { appendAudit } from "./audit.js";
+import { applyPatchProposal, createPatchProposal } from "./patches.js";
+const execFileAsync = promisify(execFile);
+function dryRunResult(tool, files = []) {
+    return { ok: true, output: `[dry-run] ${tool} skipped execution.`, files };
+}
+async function withAudit(context, tool, args, affectedFiles, runner) {
+    try {
+        const result = await runner();
+        await appendAudit({
+            timestamp: new Date().toISOString(),
+            workspace: context.workspacePath,
+            tool,
+            args,
+            affectedFiles: affectedFiles.map((f) => path.relative(context.workspacePath, f)),
+            dryRun: context.settings.dryRun,
+            ok: result.ok,
+            error: result.error
+        });
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await appendAudit({
+            timestamp: new Date().toISOString(),
+            workspace: context.workspacePath,
+            tool,
+            args,
+            affectedFiles: affectedFiles.map((f) => path.relative(context.workspacePath, f)),
+            dryRun: context.settings.dryRun,
+            ok: false,
+            error: message
+        });
+        return { ok: false, error: message };
+    }
+}
+export async function executeTool(context, tool, args) {
+    switch (tool) {
+        case "listDirectory":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const rel = parsed.pathRelativeToWorkspace ?? ".";
+                const full = resolveInWorkspace(context.workspacePath, rel);
+                if (context.settings.dryRun)
+                    return dryRunResult(tool, [full]);
+                const entries = await fs.readdir(full, { withFileTypes: true });
+                const lines = entries.map((e) => `${e.isDirectory() ? "d" : "f"} ${e.name}`);
+                return { ok: true, output: lines.join("\n"), files: [full] };
+            });
+        case "readFile":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const full = resolveInWorkspace(context.workspacePath, parsed.pathRelativeToWorkspace);
+                if (context.settings.dryRun)
+                    return dryRunResult(tool, [full]);
+                const content = await fs.readFile(full, "utf8");
+                return { ok: true, output: content, files: [full] };
+            });
+        case "writeFile":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const full = resolveInWorkspace(context.workspacePath, parsed.pathRelativeToWorkspace);
+                const proposal = await createPatchProposal(context.workspacePath, parsed.pathRelativeToWorkspace, parsed.content, {
+                    persist: !context.settings.dryRun,
+                    preApproveAll: context.settings.executionMode === "autonomous"
+                });
+                if (context.settings.dryRun) {
+                    return {
+                        ok: true,
+                        output: `[dry-run] writeFile generated patch preview for ${parsed.pathRelativeToWorkspace}.`,
+                        files: [full]
+                    };
+                }
+                if (context.settings.executionMode === "safe") {
+                    return {
+                        ok: true,
+                        output: `Patch proposal created: ${proposal.id}`,
+                        files: [full],
+                        patchProposalId: proposal.id
+                    };
+                }
+                await applyPatchProposal(context.workspacePath, proposal.id);
+                return {
+                    ok: true,
+                    output: `Applied patch ${proposal.id} to ${parsed.pathRelativeToWorkspace}`,
+                    files: [full],
+                    patchProposalId: proposal.id
+                };
+            });
+        case "searchInFiles":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                if (context.settings.dryRun)
+                    return dryRunResult(tool);
+                const files = await fg(["**/*"], {
+                    cwd: context.workspacePath,
+                    onlyFiles: true,
+                    ignore: ["node_modules/**", ".git/**", "dist/**"]
+                });
+                const hits = [];
+                for (const file of files.slice(0, 2000)) {
+                    const full = resolveInWorkspace(context.workspacePath, file);
+                    const content = await fs.readFile(full, "utf8").catch(() => "");
+                    if (content.includes(parsed.query))
+                        hits.push(file);
+                    if (hits.length >= 200)
+                        break;
+                }
+                return { ok: true, output: hits.join("\n") || "No matches.", files: hits };
+            });
+        case "gitStatus":
+            return withAudit(context, tool, args, [], async () => {
+                if (context.settings.dryRun)
+                    return dryRunResult(tool);
+                const { stdout, stderr } = await execFileAsync("git", ["status", "--short"], { cwd: context.workspacePath });
+                return { ok: true, output: `${stdout}${stderr}`.trim() || "Clean working tree." };
+            });
+        case "gitDiff":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const relPath = parsed.path ? resolveInWorkspace(context.workspacePath, parsed.path) : undefined;
+                if (context.settings.dryRun)
+                    return dryRunResult(tool, relPath ? [relPath] : []);
+                const diffArgs = ["diff"];
+                if (parsed.path)
+                    diffArgs.push("--", path.relative(context.workspacePath, relPath));
+                const { stdout, stderr } = await execFileAsync("git", diffArgs, { cwd: context.workspacePath });
+                return { ok: true, output: `${stdout}${stderr}`.trim() || "No diff." };
+            });
+        case "runCommand":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const cwd = resolveInWorkspace(context.workspacePath, parsed.cwdRelativeToWorkspace ?? ".");
+                if (context.settings.dryRun)
+                    return dryRunResult(tool, [cwd]);
+                const { stdout, stderr } = await execFileAsync(parsed.cmd, parsed.args ?? [], { cwd });
+                return { ok: true, output: `${stdout}${stderr}`.trim() };
+            });
+        default:
+            return { ok: false, error: "Unknown tool." };
+    }
+}