@agjs/tsforge 0.5.0 → 0.5.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agjs/tsforge",
   "type": "module",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "license": "MIT",
   "description": "TypeScript coding harness with a deterministic gate, stack-aware guardrails, and stream-level correction.",
   "repository": {

package/src/agent/agent.constants.ts

@@ -16,6 +16,7 @@ export const TOOL_NAME = {
   typeAt: "type_at",
   diagnostics: "diagnostics",
   renameSymbol: "rename_symbol",
+  moveFile: "move_file",
   organizeImports: "organize_imports",
   scaffoldUi: "scaffold_ui",
   scaffoldRoutes: "scaffold_routes",
@@ -379,4 +380,17 @@ export const LSP_TOOLS = [
       },
     },
   },
+  {
+    type: "function",
+    function: {
+      name: TOOL_NAME.moveFile,
+      description:
+        "Move/rename a FILE and rewrite every import that points at it (and its own relative imports) in one step — compiler-accurate, no manual edits. Rejected if the source, destination, or any importer is read-only/out-of-scope.",
+      parameters: {
+        type: "object",
+        properties: { from: { type: "string" }, to: { type: "string" } },
+        required: ["from", "to"],
+      },
+    },
+  },
 ];

package/src/detect-gate.ts

@@ -142,6 +142,11 @@ const STRICT_TSCONFIG_OVERLAY = `{
 /** The gate overlay's home: tsforge's cache dir + the overlay filename. */
 const GATE_TSCONFIG_DIR = ".tsforge";
 const GATE_TSCONFIG_FILE = "tsconfig.gate.json";
+/** Persistent incremental-typecheck cache (in .tsforge/, git-ignored). Reused
+ *  across settles so a warm `tsc` only re-checks what changed — tsc stays the
+ *  authority, just amortized. */
+const GATE_TSBUILDINFO_FILE = "gate.tsbuildinfo";
+const INCREMENTAL_FLAGS = `--incremental --tsBuildInfoFile ${GATE_TSCONFIG_DIR}/${GATE_TSBUILDINFO_FILE}`;
 
 // The web-stack scaffolds (Vite + React full-kit, or Vite vanilla) live in the
 // registry; this module just lays them down and builds their gate. shadcn/TanStack
@@ -780,7 +785,7 @@ async function tscPart(cwd: string): Promise<string | null> {
     );
     await ignoreGateArtifact(cwd);
 
-    return `"${TSC_BIN}" --noEmit -p ${GATE_TSCONFIG_DIR}/${GATE_TSCONFIG_FILE}`;
+    return `"${TSC_BIN}" --noEmit ${INCREMENTAL_FLAGS} -p ${GATE_TSCONFIG_DIR}/${GATE_TSCONFIG_FILE}`;
   }
 
   // Greenfield: bring a strict tsconfig so tsc can gate — but only when this is
@@ -788,8 +793,11 @@ async function tscPart(cwd: string): Promise<string | null> {
   // Unlike the overlay, a greenfield tsconfig.json is a DURABLE project file.
   if (await Bun.file(join(cwd, "package.json")).exists()) {
     await Bun.write(join(cwd, "tsconfig.json"), STRICT_TSCONFIG);
+    // The buildinfo lives in .tsforge/ (git-ignored), NOT next to the durable
+    // tsconfig — so incremental never leaks a cache file into the user's tree.
+    await ignoreGateArtifact(cwd);
 
-    return `"${TSC_BIN}" --noEmit -p tsconfig.json`;
+    return `"${TSC_BIN}" --noEmit ${INCREMENTAL_FLAGS} -p tsconfig.json`;
   }
 
   return null;
@@ -801,12 +809,26 @@ async function tscPart(cwd: string): Promise<string | null> {
  *  that intentionally tracks rules.json) is never clobbered. */
 async function ignoreGateArtifact(cwd: string): Promise<void> {
   const ignore = join(cwd, GATE_TSCONFIG_DIR, ".gitignore");
+  const entries = [GATE_TSCONFIG_FILE, GATE_TSBUILDINFO_FILE];
+  const file = Bun.file(ignore);
+
+  if (!(await file.exists())) {
+    await Bun.write(ignore, `${entries.join("\n")}\n`);
 
-  if (await Bun.file(ignore).exists()) {
     return;
   }
 
-  await Bun.write(ignore, `${GATE_TSCONFIG_FILE}\n`);
+  // Exists (maybe a user's, or an older tsforge one without the buildinfo line):
+  // append only the missing entries so we never clobber what's there.
+  const current = await file.text();
+  const missing = entries.filter((e) => !current.split("\n").includes(e));
+
+  if (missing.length > 0) {
+    await Bun.write(
+      ignore,
+      `${current.replace(/\n*$/u, "\n")}${missing.join("\n")}\n`
+    );
+  }
 }
 
 /** The syntactic idiom layer — ALWAYS tsforge's bundled strict eslint config

package/src/loop/tools/execute-tool.ts

@@ -30,6 +30,7 @@ const HANDLERS: Record<ToolName, ToolHandler> = {
   [TOOL_NAME.typeAt]: (a, c) => doLsp(TOOL_NAME.typeAt, a, c),
   [TOOL_NAME.diagnostics]: (a, c) => doLsp(TOOL_NAME.diagnostics, a, c),
   [TOOL_NAME.renameSymbol]: (a, c) => doLsp(TOOL_NAME.renameSymbol, a, c),
+  [TOOL_NAME.moveFile]: (a, c) => doLsp(TOOL_NAME.moveFile, a, c),
   [TOOL_NAME.organizeImports]: (a, c) => doLsp(TOOL_NAME.organizeImports, a, c),
   [TOOL_NAME.scaffoldUi]: doScaffoldUi,
   [TOOL_NAME.scaffoldRoutes]: doScaffoldRoutes,

package/src/loop/tools/lsp-ops.ts

@@ -1,7 +1,7 @@
 import { relative } from "node:path";
 import { fileArg, TOOL_NAME, type ToolName } from "../../agent";
 import { runArgvCommand } from "../../lib/fs";
-import { writable } from "../../lib/scope";
+import { writable, isVendored } from "../../lib/scope";
 import { LOOP_LIMITS } from "../loop.constants";
 import { str, reject, type IToolContext } from "./tool-context";
 
@@ -137,10 +137,57 @@ export function doLsp(
     return `organize_imports: ${n} change(s) in ${file}`;
   }
 
+  // move_file takes {from, to} (not {file, symbol}) — handle before doSymbolLsp's
+  // symbol guard. Scope-enforced: a move rewrites importers across the project; it
+  // must NOT touch read-only/out-of-scope/vendored files.
+  if (name === TOOL_NAME.moveFile) {
+    return doMoveFile(svc, args, ctx, rel);
+  }
+
   // The remaining tools address a symbol by name within a file.
   return doSymbolLsp(name, svc, file, args, ctx, rel);
 }
 
+/** move_file: relocate a file and rewrite every importer's specifier. */
+function doMoveFile(
+  svc: LspService,
+  args: Record<string, unknown>,
+  ctx: IToolContext,
+  rel: (abs: string) => string
+): string {
+  const from = str(args, "from");
+  const to = str(args, "to");
+
+  if (from.length === 0 || to.length === 0) {
+    return "move_file: need {from, to}";
+  }
+
+  const targets = svc.moveTargets(from, to).map(rel);
+  const blocked = targets.filter(
+    (t) => !writable(t, ctx.files) || isVendored(t, ctx.vendored ?? [])
+  );
+
+  if (blocked.length > 0) {
+    return reject(
+      ctx,
+      "move_file",
+      `move '${from}' → '${to}' REJECTED: would touch out-of-scope/read-only file(s): ${blocked.join(", ")}. Move files only when the source, destination, and every importer are in your editable scope.`
+    );
+  }
+
+  const changed = svc.moveFile(from, to);
+
+  ctx.report({
+    kind: "tool",
+    task: ctx.task,
+    message: `move_file ${from}→${to} (${changed ?? 0})`,
+  });
+
+  return changed === null
+    ? `move_file: source '${from}' not found`
+    : `moved '${from}' → '${to}', updated imports across ${changed} file(s)`;
+}
+
 type LspService = NonNullable<IToolContext["tsService"]>;
 
 /** The LSP tools that resolve a symbol position first (type_at, find_references,

package/src/lsp/service.ts

@@ -1,4 +1,5 @@
-import { join, isAbsolute } from "node:path";
+import { join, isAbsolute, dirname } from "node:path";
+import { mkdirSync, rmSync } from "node:fs";
 import ts from "typescript";
 import type {
   ITsDiagnostic,
@@ -451,6 +452,73 @@ export class TsService {
     return [...new Set((locs ?? []).map((l) => l.fileName))];
   }
 
+  /** Edits a file move would produce (rewriting importers + the file's own
+   *  relative imports). Absolute paths. */
+  private moveEdits(
+    fromAbs: string,
+    toAbs: string
+  ): readonly ts.FileTextChanges[] {
+    return this.service.getEditsForFileRename(
+      fromAbs,
+      toAbs,
+      ts.getDefaultFormatCodeSettings("\n"),
+      {}
+    );
+  }
+
+  /** Which files a move would touch — every importer plus the source and
+   *  destination — for scope-checking BEFORE applying. Absolute paths. */
+  moveTargets(fromRel: string, toRel: string): string[] {
+    const fromAbs = this.toAbs(fromRel);
+    const toAbs = this.toAbs(toRel);
+    const touched = new Set(
+      this.moveEdits(fromAbs, toAbs).map((e) => e.fileName)
+    );
+
+    touched.add(fromAbs);
+    touched.add(toAbs);
+
+    return [...touched];
+  }
+
+  /**
+   * Move a file and rewrite every import that points at it (and its own relative
+   * imports), compiler-accurately via getEditsForFileRename. Returns the number
+   * of files changed (incl. the moved file), or null if the source can't be read.
+   * Callers MUST enforce scope first (a move can touch read-only files).
+   */
+  moveFile(fromRel: string, toRel: string): number | null {
+    const fromAbs = this.toAbs(fromRel);
+    const toAbs = this.toAbs(toRel);
+    const original = ts.sys.readFile(fromAbs);
+
+    if (original === undefined) {
+      return null;
+    }
+
+    const edits = this.moveEdits(fromAbs, toAbs);
+
+    // Apply the import rewrites (importers + the moved file's own imports) while
+    // the file still lives at its old path, THEN relocate the edited content.
+    this.applyChanges(edits);
+
+    const moved = ts.sys.readFile(fromAbs) ?? original;
+
+    mkdirSync(dirname(toAbs), { recursive: true });
+    ts.sys.writeFile(toAbs, moved);
+    rmSync(fromAbs, { force: true });
+
+    const stale = this.files.indexOf(fromAbs);
+
+    if (stale >= 0) {
+      this.files.splice(stale, 1);
+    }
+
+    this.refresh(toRel);
+
+    return new Set([...edits.map((e) => e.fileName), fromAbs]).size;
+  }
+
   /** Organize imports (dedupe/sort/drop unused) for one file. Returns edits made. */
   organizeImports(file: string): number {
     const changes = this.service.organizeImports(