@agjs/tsforge 0.5.0 → 0.5.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agjs/tsforge",
   "type": "module",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "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/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(