@movesafe/mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 endrilickollari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CORE_VERSION } from "@movesafe/core";
+import { z as z2 } from "zod";
+
+// src/apply-move.ts
+import { resolve } from "path";
+import { applyMove, planMove } from "@movesafe/core";
+function hashMismatch(planHash) {
+  return {
+    ok: false,
+    status: "hash-mismatch",
+    planHash,
+    diagnostics: [
+      {
+        severity: "error",
+        code: "plan-hash-mismatch",
+        message: "The plan for this move has changed since it was reviewed. Call plan_move again and review the new plan.",
+        path: void 0
+      }
+    ],
+    manualRecoveryPaths: []
+  };
+}
+function applyMoveTool(options) {
+  const from = resolve(options.cwd, options.from);
+  const to = resolve(options.cwd, options.to);
+  const plan = planMove({ from, to, cwd: options.cwd });
+  if (plan.planHash !== options.planHash) {
+    return hashMismatch(options.planHash);
+  }
+  if (plan.status === "blocked") {
+    return {
+      ok: false,
+      status: "rejected",
+      planHash: plan.planHash,
+      diagnostics: plan.diagnostics,
+      manualRecoveryPaths: []
+    };
+  }
+  const result = applyMove(plan);
+  return {
+    ok: result.status === "applied",
+    status: result.status,
+    planHash: plan.planHash,
+    diagnostics: [...plan.diagnostics, ...result.diagnostics],
+    manualRecoveryPaths: result.manualRecoveryPaths
+  };
+}
+
+// src/check-imports.ts
+import { resolve as resolve2 } from "path";
+import { checkImports as checkCoreImports } from "@movesafe/core";
+function checkImports(options) {
+  const target = resolve2(options.cwd, options.path ?? ".");
+  const result = checkCoreImports({ path: target, cwd: options.cwd });
+  const findings = [...result.findings, ...result.diagnostics];
+  const noConfig = result.diagnostics.find((diagnostic) => diagnostic.code === "no-tsconfig-found");
+  const errorCount = findings.filter((finding) => finding.severity === "error").length;
+  const warningCount = findings.filter((finding) => finding.severity === "warning").length;
+  const infoCount = findings.filter((finding) => finding.severity === "info").length;
+  return {
+    ok: result.clean,
+    error: noConfig?.message,
+    findings,
+    summary: { errorCount, warningCount, infoCount, total: findings.length }
+  };
+}
+
+// src/plan-move.ts
+import { resolve as resolve3 } from "path";
+import { planMove as planMove2 } from "@movesafe/core";
+import { computePlanDiff } from "@movesafe/core/advanced";
+var EMPTY_DIFF = { files: [] };
+function planMoveTool(options) {
+  const from = resolve3(options.cwd, options.from);
+  const to = resolve3(options.cwd, options.to);
+  const plan = planMove2({ from, to, cwd: options.cwd });
+  return {
+    ok: plan.status === "ready",
+    status: plan.status,
+    operation: plan.operation,
+    scope: plan.scope,
+    planHash: plan.planHash,
+    moves: plan.moves,
+    edits: plan.edits,
+    diagnostics: plan.diagnostics,
+    diff: plan.status === "ready" ? computePlanDiff(plan) : EMPTY_DIFF
+  };
+}
+
+// src/schemas.ts
+import { z } from "zod";
+var diagnosticSchema = z.object({
+  severity: z.enum(["error", "warning", "info"]),
+  code: z.string(),
+  message: z.string(),
+  path: z.string().optional(),
+  source: z.enum(["workspace", "tsconfig", "scanner", "resolver"]).optional()
+});
+var editSchema = z.object({
+  file: z.string(),
+  span: z.object({ start: z.number(), end: z.number() }),
+  oldText: z.string(),
+  newText: z.string(),
+  reason: z.string()
+});
+var moveSchema = z.object({
+  fromFilePath: z.string(),
+  toFilePath: z.string()
+});
+var diffLineSchema = z.object({
+  kind: z.enum(["context", "added", "removed"]),
+  text: z.string()
+});
+var diffHunkSchema = z.object({
+  oldStart: z.number(),
+  oldLines: z.number(),
+  newStart: z.number(),
+  newLines: z.number(),
+  lines: z.array(diffLineSchema)
+});
+var fileDiffSchema = z.object({
+  oldPath: z.string(),
+  newPath: z.string(),
+  hunks: z.array(diffHunkSchema)
+});
+var diffSchema = z.object({
+  files: z.array(fileDiffSchema)
+});
+var planMoveOutputSchema = {
+  ok: z.boolean(),
+  status: z.enum(["ready", "blocked"]),
+  operation: z.enum(["file", "directory"]),
+  scope: z.enum(["project", "workspace"]),
+  planHash: z.string(),
+  moves: z.array(moveSchema),
+  edits: z.array(editSchema),
+  diagnostics: z.array(diagnosticSchema),
+  diff: diffSchema
+};
+var applyMoveOutputSchema = {
+  ok: z.boolean(),
+  status: z.enum(["applied", "rejected", "partial", "hash-mismatch"]),
+  planHash: z.string(),
+  diagnostics: z.array(diagnosticSchema),
+  manualRecoveryPaths: z.array(z.string())
+};
+var checkImportsOutputSchema = {
+  ok: z.boolean(),
+  error: z.string().optional(),
+  findings: z.array(diagnosticSchema),
+  summary: z.object({
+    errorCount: z.number(),
+    warningCount: z.number(),
+    infoCount: z.number(),
+    total: z.number()
+  })
+};
+
+// src/server.ts
+function structuredResult(structuredContent, text) {
+  return { content: [{ type: "text", text }], structuredContent, isError: false };
+}
+function toolError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+function summarizePlan(plan) {
+  if (plan.status === "blocked") {
+    const errorCount = plan.diagnostics.filter((d) => d.severity === "error").length;
+    return `Plan blocked: ${errorCount} error(s).`;
+  }
+  const fileCount = new Set(plan.diff.files.map((file) => file.newPath)).size;
+  return `Plan ready: ${plan.edits.length} edit(s) across ${fileCount} file(s). Hash ${plan.planHash}.`;
+}
+function summarizeApply(result) {
+  switch (result.status) {
+    case "applied":
+      return "Applied.";
+    case "hash-mismatch":
+      return "Rejected: plan hash mismatch \u2014 call plan_move again and apply the new hash.";
+    case "partial":
+      return `Partial: ${result.manualRecoveryPaths.length} path(s) need manual recovery.`;
+    case "rejected":
+      return `Rejected: ${result.diagnostics.find((d) => d.severity === "error")?.message ?? "plan failed validation."}`;
+  }
+}
+function createServer() {
+  const server = new McpServer({ name: "movesafe", version: CORE_VERSION });
+  server.registerTool(
+    "plan_move",
+    {
+      title: "Plan a move",
+      description: "Plans moving a TypeScript file, directory, or cross-package file, rewriting every import that references it. Read-only \u2014 never touches disk. Returns a planHash to pass to apply_move.",
+      inputSchema: {
+        from: z2.string().describe("Path to the file or directory to move"),
+        to: z2.string().describe("Destination path")
+      },
+      outputSchema: planMoveOutputSchema
+    },
+    ({ from, to }) => {
+      try {
+        const result = planMoveTool({ from, to, cwd: process.cwd() });
+        return structuredResult(result, summarizePlan(result));
+      } catch (error) {
+        return toolError(error);
+      }
+    }
+  );
+  server.registerTool(
+    "apply_move",
+    {
+      title: "Apply a planned move",
+      description: "Applies the move planned by plan_move. Recomputes the plan from current disk state and refuses (hash-mismatch) if it no longer matches the supplied planHash \u2014 never applies a plan different from the one reviewed.",
+      inputSchema: {
+        from: z2.string().describe("Path to the file or directory to move"),
+        to: z2.string().describe("Destination path"),
+        planHash: z2.string().describe("The planHash returned by plan_move for this exact move")
+      },
+      outputSchema: applyMoveOutputSchema
+    },
+    ({ from, to, planHash }) => {
+      try {
+        const result = applyMoveTool({ from, to, planHash, cwd: process.cwd() });
+        return structuredResult(result, summarizeApply(result));
+      } catch (error) {
+        return toolError(error);
+      }
+    }
+  );
+  server.registerTool(
+    "check_imports",
+    {
+      title: "Check imports",
+      description: "Scans a project for unresolvable imports, orphaned barrel exports, and case-sensitivity mismatches.",
+      inputSchema: {
+        path: z2.string().optional().describe("Directory to check (defaults to the current directory)")
+      },
+      outputSchema: checkImportsOutputSchema
+    },
+    ({ path }) => {
+      try {
+        const result = checkImports({ path, cwd: process.cwd() });
+        const text = result.ok ? "Clean." : `${result.summary.errorCount} error(s), ${result.summary.warningCount} warning(s).`;
+        return structuredResult(result, text);
+      } catch (error) {
+        return toolError(error);
+      }
+    }
+  );
+  return server;
+}
+
+// src/index.ts
+var isMainModule = process.argv[1] !== void 0 && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMainModule) {
+  await createServer().connect(new StdioServerTransport());
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@movesafe/mcp",
+  "version": "0.1.0",
+  "description": "MCP server for planning and applying safe TypeScript file moves.",
+  "license": "MIT",
+  "author": "Endri Liçkollari",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/endrilickollari/movesafe.git",
+    "directory": "packages/mcp"
+  },
+  "homepage": "https://github.com/endrilickollari/movesafe#readme",
+  "bugs": {
+    "url": "https://github.com/endrilickollari/movesafe/issues"
+  },
+  "keywords": [
+    "typescript",
+    "refactoring",
+    "mcp"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "type": "module",
+  "bin": {
+    "movesafe-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "zod": "^3.25.76",
+    "@movesafe/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.10"
+  },
+  "scripts": {
+    "build": "tsup",
+    "lint": "eslint .",
+    "test": "vitest run"
+  }
+}