terry-core 0.1.0

package/dist/audit.d.ts

@@ -0,0 +1,3 @@
+import type { AuditEntry } from "./types.js";
+export declare function appendAudit(entry: AuditEntry): Promise<void>;
+export declare function readAuditLines(limit?: number): Promise<string[]>;

package/dist/audit.js

@@ -0,0 +1,17 @@
+import fs from "node:fs/promises";
+import { auditLogFile, ensureTerryDirs } from "./config.js";
+export async function appendAudit(entry) {
+    await ensureTerryDirs();
+    await fs.appendFile(auditLogFile(), `${JSON.stringify(entry)}\n`, "utf8");
+}
+export async function readAuditLines(limit = 200) {
+    await ensureTerryDirs();
+    try {
+        const raw = await fs.readFile(auditLogFile(), "utf8");
+        const lines = raw.trim().split("\n");
+        return lines.slice(Math.max(0, lines.length - limit));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+import { type WorkspaceSettings } from "./types.js";
+export declare function terryHomeDir(): string;
+export declare function workspacesFile(): string;
+export declare function auditLogFile(): string;
+export declare function usageDir(): string;
+export declare function cloudSyncConfigFile(): string;
+export declare function ensureTerryDirs(): Promise<void>;
+type WorkspaceMap = Record<string, WorkspaceSettings>;
+export declare function loadWorkspaceMap(): Promise<WorkspaceMap>;
+export declare function saveWorkspaceMap(map: WorkspaceMap): Promise<void>;
+export declare function getWorkspaceSettings(workspacePath: string): Promise<WorkspaceSettings>;
+export declare function setWorkspaceSettings(workspacePath: string, patch: Partial<WorkspaceSettings>): Promise<WorkspaceSettings>;
+export {};

package/dist/config.js

@@ -0,0 +1,107 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+const DEFAULT_MODE = "general";
+const DEFAULT_EXECUTION_MODE = "safe";
+const DEFAULT_TOOLS = {
+    listDirectory: "enabled",
+    readFile: "enabled",
+    writeFile: "enabled",
+    searchInFiles: "enabled",
+    gitStatus: "enabled",
+    gitDiff: "enabled",
+    runCommand: "enabled"
+};
+export function terryHomeDir() {
+    return path.join(os.homedir(), ".terry");
+}
+export function workspacesFile() {
+    return path.join(terryHomeDir(), "workspaces.json");
+}
+export function auditLogFile() {
+    return path.join(terryHomeDir(), "audit.log.jsonl");
+}
+export function usageDir() {
+    return path.join(terryHomeDir(), "usage");
+}
+export function cloudSyncConfigFile() {
+    return path.join(terryHomeDir(), "cloud-sync.json");
+}
+export async function ensureTerryDirs() {
+    await fs.mkdir(terryHomeDir(), { recursive: true });
+    await fs.mkdir(usageDir(), { recursive: true });
+}
+export async function loadWorkspaceMap() {
+    await ensureTerryDirs();
+    try {
+        const raw = await fs.readFile(workspacesFile(), "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export async function saveWorkspaceMap(map) {
+    await ensureTerryDirs();
+    await fs.writeFile(workspacesFile(), JSON.stringify(map, null, 2), "utf8");
+}
+export async function getWorkspaceSettings(workspacePath) {
+    const map = await loadWorkspaceMap();
+    const key = path.resolve(workspacePath);
+    if (!map[key]) {
+        map[key] = {
+            workspacePath: key,
+            dryRun: false,
+            mode: DEFAULT_MODE,
+            executionMode: DEFAULT_EXECUTION_MODE,
+            tools: { ...DEFAULT_TOOLS }
+        };
+        await saveWorkspaceMap(map);
+    }
+    else if (!map[key].mode || !map[key].executionMode) {
+        map[key] = {
+            ...map[key],
+            mode: DEFAULT_MODE,
+            executionMode: map[key].executionMode ?? DEFAULT_EXECUTION_MODE,
+            tools: { ...DEFAULT_TOOLS, ...map[key].tools }
+        };
+        await saveWorkspaceMap(map);
+    }
+    else {
+        const levels = Object.values(map[key].tools ?? {});
+        const allDisabled = levels.length > 0 && levels.every((level) => level === "disabled");
+        const legacyPattern = map[key].tools?.listDirectory === "disabled" &&
+            map[key].tools?.readFile === "disabled" &&
+            map[key].tools?.searchInFiles === "disabled" &&
+            map[key].tools?.gitStatus === "disabled" &&
+            map[key].tools?.gitDiff === "disabled" &&
+            map[key].tools?.writeFile === "ask" &&
+            map[key].tools?.runCommand === "ask";
+        if (allDisabled || legacyPattern) {
+            map[key] = {
+                ...map[key],
+                tools: { ...DEFAULT_TOOLS }
+            };
+            await saveWorkspaceMap(map);
+        }
+    }
+    return map[key];
+}
+export async function setWorkspaceSettings(workspacePath, patch) {
+    const map = await loadWorkspaceMap();
+    const key = path.resolve(workspacePath);
+    const current = map[key] ?? {
+        workspacePath: key,
+        dryRun: false,
+        mode: DEFAULT_MODE,
+        executionMode: DEFAULT_EXECUTION_MODE,
+        tools: { ...DEFAULT_TOOLS }
+    };
+    map[key] = {
+        ...current,
+        ...patch,
+        tools: { ...current.tools, ...(patch.tools ?? {}) }
+    };
+    await saveWorkspaceMap(map);
+    return map[key];
+}

package/dist/explain.d.ts

@@ -0,0 +1,3 @@
+import type { ActionExplanation } from "./types.js";
+export declare function setLastExplanation(workspacePath: string, explanation: ActionExplanation): Promise<void>;
+export declare function getLastExplanation(workspacePath: string): Promise<ActionExplanation | null>;

package/dist/explain.js

@@ -0,0 +1,11 @@
+import { workspaceDataFile, readJsonFile, writeJsonFile, ensureWorkspaceDataDirs } from "./workspace-data.js";
+function explainPath(workspacePath) {
+    return workspaceDataFile(workspacePath, "explain-last.json");
+}
+export async function setLastExplanation(workspacePath, explanation) {
+    await ensureWorkspaceDataDirs(workspacePath);
+    await writeJsonFile(explainPath(workspacePath), explanation);
+}
+export async function getLastExplanation(workspacePath) {
+    return readJsonFile(explainPath(workspacePath), null);
+}

package/dist/health.d.ts

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

package/dist/health.js

@@ -0,0 +1,105 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+async function runNpm(args, cwd) {
+    if (process.platform === "win32") {
+        return execFileAsync("cmd.exe", ["/d", "/s", "/c", `npm ${args.join(" ")}`], { cwd });
+    }
+    return execFileAsync("npm", args, { cwd });
+}
+async function readPackageJson(workspacePath) {
+    try {
+        const raw = await fs.readFile(path.join(workspacePath, "package.json"), "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function scoreFromChecks(checks) {
+    let score = 100;
+    for (const check of checks) {
+        if (check.status === "warn")
+            score -= 10;
+        if (check.status === "fail")
+            score -= 25;
+    }
+    return Math.max(0, score);
+}
+function recommendationsFromChecks(checks) {
+    const out = [];
+    for (const check of checks) {
+        if (check.status === "fail")
+            out.push(`Fix failing check: ${check.name}`);
+        if (check.status === "warn")
+            out.push(`Review warning: ${check.name}`);
+    }
+    return out.slice(0, 8);
+}
+export async function runWorkspaceHealth(workspacePath) {
+    const checks = [];
+    const pkg = await readPackageJson(workspacePath);
+    try {
+        const { stdout } = await execFileAsync("git", ["status", "--short"], { cwd: workspacePath });
+        const dirty = stdout.trim().length > 0;
+        checks.push({
+            name: "git_clean_tree",
+            status: dirty ? "warn" : "pass",
+            detail: dirty ? "Working tree has local modifications." : "Working tree clean."
+        });
+    }
+    catch {
+        checks.push({ name: "git_available", status: "warn", detail: "Git status unavailable." });
+    }
+    const scripts = pkg?.scripts ?? {};
+    for (const scriptName of ["lint", "test", "build"]) {
+        if (!scripts[scriptName]) {
+            checks.push({
+                name: `script_${scriptName}`,
+                status: "warn",
+                detail: `No npm script "${scriptName}" found.`
+            });
+            continue;
+        }
+        try {
+            await runNpm(["run", scriptName, "--if-present"], workspacePath);
+            checks.push({
+                name: `script_${scriptName}`,
+                status: "pass",
+                detail: `npm run ${scriptName} succeeded.`
+            });
+        }
+        catch {
+            checks.push({
+                name: `script_${scriptName}`,
+                status: "fail",
+                detail: `npm run ${scriptName} failed.`
+            });
+        }
+    }
+    try {
+        const { stdout } = await runNpm(["outdated", "--json"], workspacePath);
+        const parsed = (stdout ? JSON.parse(stdout) : {});
+        const count = Object.keys(parsed ?? {}).length;
+        checks.push({
+            name: "dependencies_freshness",
+            status: count > 0 ? "warn" : "pass",
+            detail: count > 0 ? `${count} dependencies are outdated.` : "Dependencies are up to date."
+        });
+    }
+    catch {
+        checks.push({
+            name: "dependencies_freshness",
+            status: "warn",
+            detail: "Could not determine outdated dependencies."
+        });
+    }
+    return {
+        score: scoreFromChecks(checks),
+        checks,
+        recommendations: recommendationsFromChecks(checks),
+        generatedAt: new Date().toISOString()
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./types.js";
+export * from "./config.js";
+export * from "./sandbox.js";
+export * from "./audit.js";
+export * from "./tools.js";
+export * from "./permissions.js";
+export * from "./orchestrator.js";
+export * from "./workspace-data.js";
+export * from "./policy.js";
+export * from "./patches.js";
+export * from "./explain.js";
+export * from "./sessions.js";
+export * from "./repo.js";
+export * from "./status.js";
+export * from "./templates.js";
+export * from "./health.js";
+export * from "./usage.js";

package/dist/index.js

@@ -0,0 +1,17 @@
+export * from "./types.js";
+export * from "./config.js";
+export * from "./sandbox.js";
+export * from "./audit.js";
+export * from "./tools.js";
+export * from "./permissions.js";
+export * from "./orchestrator.js";
+export * from "./workspace-data.js";
+export * from "./policy.js";
+export * from "./patches.js";
+export * from "./explain.js";
+export * from "./sessions.js";
+export * from "./repo.js";
+export * from "./status.js";
+export * from "./templates.js";
+export * from "./health.js";
+export * from "./usage.js";

package/dist/orchestrator.d.ts

@@ -0,0 +1,2 @@
+import type { DecideNextAction } from "./types.js";
+export declare const rulesOrchestrator: DecideNextAction;

package/dist/orchestrator.js

@@ -0,0 +1,58 @@
+const TOOL_HINTS = [
+    { tool: "listDirectory", match: /\b(list|ls|folders?|files?)\b/i },
+    { tool: "readFile", match: /\b(read|open|show)\b.*\b(file|md|json|ts|js)\b/i },
+    { tool: "writeFile", match: /\b(write|create|update|edit|save)\b.*\b(file|doc|readme|json|ts|js)\b/i },
+    { tool: "searchInFiles", match: /\b(search|find|grep|look for)\b/i },
+    { tool: "gitStatus", match: /\bgit status|repo status|what changed\b/i },
+    { tool: "gitDiff", match: /\bgit diff|show diff|changes\b/i },
+    { tool: "runCommand", match: /\brun|execute|command|npm|pnpm|yarn|test|build\b/i }
+];
+function inferTool(content) {
+    for (const hint of TOOL_HINTS) {
+        if (hint.match.test(content))
+            return hint.tool;
+    }
+    return null;
+}
+function inferArgs(tool, content) {
+    if (tool === "searchInFiles") {
+        const phrase = content.split("search").pop()?.trim() || content;
+        return { query: phrase.replace(/^for\s+/i, "") };
+    }
+    if (tool === "runCommand") {
+        return { cmd: "echo", args: [content] };
+    }
+    if (tool === "listDirectory")
+        return { pathRelativeToWorkspace: "." };
+    if (tool === "gitStatus")
+        return {};
+    if (tool === "gitDiff")
+        return {};
+    if (tool === "readFile")
+        return { pathRelativeToWorkspace: "README.md" };
+    if (tool === "writeFile") {
+        return {
+            pathRelativeToWorkspace: "README.md",
+            content: `# Terry update\n\nGenerated from task:\n${content}\n`
+        };
+    }
+    return {};
+}
+export const rulesOrchestrator = (messages) => {
+    const lastUser = [...messages].reverse().find((m) => m.role === "user");
+    if (!lastUser)
+        return { kind: "summarize", summary: "No task provided." };
+    const tool = inferTool(lastUser.content);
+    if (!tool) {
+        return {
+            kind: "summarize",
+            summary: "I can help with workspace files, search, git, and command planning. Ask a concrete repo or file operation."
+        };
+    }
+    return {
+        kind: "ask_permission",
+        tool,
+        args: inferArgs(tool, lastUser.content),
+        reason: `Detected request likely needs tool: ${tool}.`
+    };
+};

package/dist/patches.d.ts

@@ -0,0 +1,12 @@
+import type { PatchProposal } from "./types.js";
+type PatchOptions = {
+    persist?: boolean;
+    preApproveAll?: boolean;
+};
+export declare function createPatchProposal(workspacePath: string, relPath: string, updatedContent: string, options?: PatchOptions): Promise<PatchProposal>;
+export declare function getPatchProposal(workspacePath: string, patchId: string): Promise<PatchProposal | null>;
+export declare function listPatchProposals(workspacePath: string, status?: PatchProposal["status"]): Promise<PatchProposal[]>;
+export declare function setPatchHunkApproval(workspacePath: string, patchId: string, hunkIds: string[] | "all", approved: boolean): Promise<PatchProposal>;
+export declare function applyPatchProposal(workspacePath: string, patchId: string): Promise<PatchProposal>;
+export declare function rejectPatchProposal(workspacePath: string, patchId: string): Promise<PatchProposal>;
+export {};

package/dist/patches.js

@@ -0,0 +1,126 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createPatch, parsePatch } from "diff";
+import { resolveInWorkspace } from "./sandbox.js";
+import { ensureWorkspaceDataDirs, listJsonFiles, readJsonFile, workspaceSubdir, writeJsonFile } from "./workspace-data.js";
+function patchDir(workspacePath) {
+    return workspaceSubdir(workspacePath, "pending-patches");
+}
+function patchFile(workspacePath, patchId) {
+    return path.join(patchDir(workspacePath), `${patchId}.json`);
+}
+function buildHunkId(index) {
+    return `hunk-${index + 1}`;
+}
+function inferRiskLevel(filePath, before, after) {
+    const ext = path.extname(filePath).toLowerCase();
+    const changedLineCount = Math.abs(after.split("\n").length - before.split("\n").length);
+    if (ext === ".env" || ext.endsWith("config") || ext === ".yml" || ext === ".yaml")
+        return "high";
+    if (changedLineCount > 80)
+        return "high";
+    if (changedLineCount > 20)
+        return "medium";
+    return "low";
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+export async function createPatchProposal(workspacePath, relPath, updatedContent, options = {}) {
+    await ensureWorkspaceDataDirs(workspacePath);
+    const fullPath = resolveInWorkspace(workspacePath, relPath);
+    const originalContent = await fs.readFile(fullPath, "utf8").catch(() => "");
+    const unifiedDiff = createPatch(relPath, originalContent, updatedContent, "before", "after", { context: 3 });
+    const parsed = parsePatch(unifiedDiff);
+    const first = parsed[0];
+    const hunks = (first?.hunks ?? []).map((hunk, index) => {
+        const before = [];
+        const after = [];
+        for (const line of hunk.lines) {
+            if (line.startsWith("-") && !line.startsWith("---"))
+                before.push(line.slice(1));
+            if (line.startsWith("+") && !line.startsWith("+++"))
+                after.push(line.slice(1));
+        }
+        return {
+            id: buildHunkId(index),
+            header: `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`,
+            before,
+            after,
+            approved: options.preApproveAll ?? false
+        };
+    });
+    const patchId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const proposal = {
+        id: patchId,
+        filePath: relPath,
+        unifiedDiff,
+        hunks,
+        riskLevel: inferRiskLevel(relPath, originalContent, updatedContent),
+        status: "pending",
+        createdAt: nowIso(),
+        updatedAt: nowIso(),
+        originalContent,
+        updatedContent
+    };
+    if (options.persist ?? true) {
+        await writeJsonFile(patchFile(workspacePath, patchId), proposal);
+    }
+    return proposal;
+}
+export async function getPatchProposal(workspacePath, patchId) {
+    return readJsonFile(patchFile(workspacePath, patchId), null);
+}
+export async function listPatchProposals(workspacePath, status) {
+    await ensureWorkspaceDataDirs(workspacePath);
+    const fileNames = await listJsonFiles(patchDir(workspacePath));
+    const proposals = [];
+    for (const name of fileNames) {
+        const filePath = path.join(patchDir(workspacePath), name);
+        const value = await readJsonFile(filePath, null);
+        if (!value)
+            continue;
+        if (status && value.status !== status)
+            continue;
+        proposals.push(value);
+    }
+    return proposals.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+export async function setPatchHunkApproval(workspacePath, patchId, hunkIds, approved) {
+    const proposal = await getPatchProposal(workspacePath, patchId);
+    if (!proposal)
+        throw new Error(`Patch proposal not found: ${patchId}`);
+    proposal.hunks = proposal.hunks.map((hunk) => {
+        const match = hunkIds === "all" ? true : hunkIds.includes(hunk.id);
+        return match ? { ...hunk, approved } : hunk;
+    });
+    proposal.updatedAt = nowIso();
+    await writeJsonFile(patchFile(workspacePath, patchId), proposal);
+    return proposal;
+}
+export async function applyPatchProposal(workspacePath, patchId) {
+    const proposal = await getPatchProposal(workspacePath, patchId);
+    if (!proposal)
+        throw new Error(`Patch proposal not found: ${patchId}`);
+    if (proposal.status !== "pending")
+        throw new Error(`Patch is already ${proposal.status}.`);
+    const unresolved = proposal.hunks.filter((hunk) => !hunk.approved);
+    if (unresolved.length > 0)
+        throw new Error(`Patch has ${unresolved.length} unapproved hunks.`);
+    const fullPath = resolveInWorkspace(workspacePath, proposal.filePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, proposal.updatedContent, "utf8");
+    proposal.status = "applied";
+    proposal.updatedAt = nowIso();
+    await writeJsonFile(patchFile(workspacePath, patchId), proposal);
+    return proposal;
+}
+export async function rejectPatchProposal(workspacePath, patchId) {
+    const proposal = await getPatchProposal(workspacePath, patchId);
+    if (!proposal)
+        throw new Error(`Patch proposal not found: ${patchId}`);
+    proposal.status = "rejected";
+    proposal.updatedAt = nowIso();
+    await writeJsonFile(patchFile(workspacePath, patchId), proposal);
+    return proposal;
+}

package/dist/permissions.d.ts

@@ -0,0 +1,6 @@
+import type { PermissionLevel, ToolName, WorkspaceSettings } from "./types.js";
+export declare function getToolPermission(settings: WorkspaceSettings, tool: ToolName): PermissionLevel;
+export declare function shouldAskEveryTime(tool: ToolName): tool is "writeFile" | "runCommand";
+export declare function isToolAllowedWithoutPrompt(settings: WorkspaceSettings, tool: ToolName): boolean;
+export declare function isToolEnabled(settings: WorkspaceSettings, tool: ToolName): boolean;
+export declare function toolRiskLevel(tool: ToolName): "low" | "medium" | "high";

package/dist/permissions.js

@@ -0,0 +1,20 @@
+export function getToolPermission(settings, tool) {
+    return settings.tools[tool] ?? "disabled";
+}
+export function shouldAskEveryTime(tool) {
+    return tool === "runCommand" || tool === "writeFile";
+}
+export function isToolAllowedWithoutPrompt(settings, tool) {
+    const level = getToolPermission(settings, tool);
+    return level === "enabled" && !shouldAskEveryTime(tool);
+}
+export function isToolEnabled(settings, tool) {
+    return getToolPermission(settings, tool) !== "disabled";
+}
+export function toolRiskLevel(tool) {
+    if (tool === "runCommand")
+        return "high";
+    if (tool === "writeFile")
+        return "medium";
+    return "low";
+}

package/dist/policy.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutionMode, ToolName, WorkspaceSettings } from "./types.js";
+export declare function isReadOnlyTool(tool: ToolName): boolean;
+export declare function isCommandAllowlisted(command: string): boolean;
+export declare function executionMode(settings: WorkspaceSettings): ExecutionMode;
+export declare function shouldExecuteInMode(settings: WorkspaceSettings, tool: ToolName, args: unknown): {
+    execute: boolean;
+    ask: boolean;
+    reason: string;
+};

package/dist/policy.js

@@ -0,0 +1,33 @@
+const READ_ONLY_TOOLS = ["listDirectory", "readFile", "searchInFiles", "gitStatus", "gitDiff"];
+const COMMAND_ALLOWLIST = new Set(["git", "npm", "pnpm", "yarn", "node", "npx"]);
+export function isReadOnlyTool(tool) {
+    return READ_ONLY_TOOLS.includes(tool);
+}
+export function isCommandAllowlisted(command) {
+    return COMMAND_ALLOWLIST.has(command.trim().toLowerCase());
+}
+export function executionMode(settings) {
+    return settings.executionMode;
+}
+export function shouldExecuteInMode(settings, tool, args) {
+    const mode = executionMode(settings);
+    if (mode === "plan") {
+        return { execute: false, ask: false, reason: "Plan mode does not execute tools." };
+    }
+    if (mode === "safe") {
+        if (isReadOnlyTool(tool))
+            return { execute: true, ask: false, reason: "Safe mode auto-executes read-only tools." };
+        return { execute: false, ask: true, reason: "Safe mode requires approval for writes and commands." };
+    }
+    if (tool === "runCommand") {
+        const cmd = args?.cmd ?? "";
+        if (!isCommandAllowlisted(cmd)) {
+            return {
+                execute: false,
+                ask: true,
+                reason: `Autonomous mode requires approval for non-allowlisted command: ${cmd || "unknown"}.`
+            };
+        }
+    }
+    return { execute: true, ask: false, reason: "Autonomous mode executes approved plan directly." };
+}

package/dist/repo.d.ts

@@ -0,0 +1,6 @@
+import type { ImpactResult, RepoGraph } from "./types.js";
+export declare function scanWorkspaceGraph(workspacePath: string): Promise<RepoGraph>;
+export declare function getWorkspaceGraph(workspacePath: string): Promise<RepoGraph | null>;
+export declare function graphToTree(graph: RepoGraph): string;
+export declare function suggestTarget(graph: RepoGraph): string | undefined;
+export declare function calculateImpact(workspacePath: string, target: string): Promise<ImpactResult>;