planmode 0.3.0 → 0.4.0

package/dist/mcp.js

@@ -1,112 +1,361 @@
 #!/usr/bin/env node
-
-// src/mcp.ts
-import fs12 from "fs";
-import path12 from "path";
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod/v4";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/lib/logger.ts
-var RESET = "\x1B[0m";
-var RED = "\x1B[31m";
-var GREEN = "\x1B[32m";
-var YELLOW = "\x1B[33m";
-var CYAN = "\x1B[36m";
-var DIM = "\x1B[2m";
-var BOLD = "\x1B[1m";
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
-var capturing = false;
-var captured = [];
-var logger = {
-  capture() {
-    capturing = true;
-    captured = [];
-  },
-  flush() {
-    const messages = captured;
-    captured = [];
+var RESET, RED, GREEN, YELLOW, CYAN, DIM, BOLD, capturing, captured, logger;
+var init_logger = __esm({
+  "src/lib/logger.ts"() {
+    "use strict";
+    RESET = "\x1B[0m";
+    RED = "\x1B[31m";
+    GREEN = "\x1B[32m";
+    YELLOW = "\x1B[33m";
+    CYAN = "\x1B[36m";
+    DIM = "\x1B[2m";
+    BOLD = "\x1B[1m";
     capturing = false;
-    return messages;
-  },
-  isCapturing() {
-    return capturing;
-  },
-  info(msg) {
-    const text2 = `info ${msg}`;
-    if (capturing) {
-      captured.push(stripAnsi(text2));
-    } else {
-      console.log(`${CYAN}info${RESET} ${msg}`);
-    }
-  },
-  success(msg) {
-    const text2 = `\u2713 ${msg}`;
-    if (capturing) {
-      captured.push(stripAnsi(text2));
-    } else {
-      console.log(`${GREEN}\u2713${RESET} ${msg}`);
-    }
-  },
-  warn(msg) {
-    const text2 = `warn ${msg}`;
-    if (capturing) {
-      captured.push(stripAnsi(text2));
-    } else {
-      console.log(`${YELLOW}warn${RESET} ${msg}`);
-    }
-  },
-  error(msg) {
-    const text2 = `error ${msg}`;
-    if (capturing) {
-      captured.push(stripAnsi(text2));
-    } else {
-      console.error(`${RED}error${RESET} ${msg}`);
-    }
-  },
-  dim(msg) {
-    if (capturing) {
-      captured.push(msg);
-    } else {
-      console.log(`${DIM}${msg}${RESET}`);
-    }
-  },
-  bold(msg) {
-    if (capturing) {
-      captured.push(msg);
-    } else {
-      console.log(`${BOLD}${msg}${RESET}`);
-    }
-  },
-  table(headers, rows) {
-    const colWidths = headers.map(
-      (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length))
-    );
-    const header = headers.map((h, i) => h.toUpperCase().padEnd(colWidths[i])).join("  ");
-    if (capturing) {
-      captured.push(`  ${header}`);
-      for (const row of rows) {
-        const line = row.map((cell, i) => cell.padEnd(colWidths[i])).join("  ");
-        captured.push(`  ${line}`);
+    captured = [];
+    logger = {
+      capture() {
+        capturing = true;
+        captured = [];
+      },
+      flush() {
+        const messages = captured;
+        captured = [];
+        capturing = false;
+        return messages;
+      },
+      isCapturing() {
+        return capturing;
+      },
+      info(msg) {
+        const text2 = `info ${msg}`;
+        if (capturing) {
+          captured.push(stripAnsi(text2));
+        } else {
+          console.log(`${CYAN}info${RESET} ${msg}`);
+        }
+      },
+      success(msg) {
+        const text2 = `\u2713 ${msg}`;
+        if (capturing) {
+          captured.push(stripAnsi(text2));
+        } else {
+          console.log(`${GREEN}\u2713${RESET} ${msg}`);
+        }
+      },
+      warn(msg) {
+        const text2 = `warn ${msg}`;
+        if (capturing) {
+          captured.push(stripAnsi(text2));
+        } else {
+          console.log(`${YELLOW}warn${RESET} ${msg}`);
+        }
+      },
+      error(msg) {
+        const text2 = `error ${msg}`;
+        if (capturing) {
+          captured.push(stripAnsi(text2));
+        } else {
+          console.error(`${RED}error${RESET} ${msg}`);
+        }
+      },
+      dim(msg) {
+        if (capturing) {
+          captured.push(msg);
+        } else {
+          console.log(`${DIM}${msg}${RESET}`);
+        }
+      },
+      bold(msg) {
+        if (capturing) {
+          captured.push(msg);
+        } else {
+          console.log(`${BOLD}${msg}${RESET}`);
+        }
+      },
+      table(headers, rows) {
+        const colWidths = headers.map(
+          (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length))
+        );
+        const header = headers.map((h, i) => h.toUpperCase().padEnd(colWidths[i])).join("  ");
+        if (capturing) {
+          captured.push(`  ${header}`);
+          for (const row of rows) {
+            const line = row.map((cell, i) => cell.padEnd(colWidths[i])).join("  ");
+            captured.push(`  ${line}`);
+          }
+        } else {
+          console.log(`  ${DIM}${header}${RESET}`);
+          for (const row of rows) {
+            const line = row.map((cell, i) => cell.padEnd(colWidths[i])).join("  ");
+            console.log(`  ${line}`);
+          }
+        }
+      },
+      blank() {
+        if (capturing) {
+          captured.push("");
+        } else {
+          console.log();
+        }
       }
-    } else {
-      console.log(`  ${DIM}${header}${RESET}`);
-      for (const row of rows) {
-        const line = row.map((cell, i) => cell.padEnd(colWidths[i])).join("  ");
-        console.log(`  ${line}`);
+    };
+  }
+});
+
+// src/lib/context.ts
+var context_exports = {};
+__export(context_exports, {
+  addContextRepo: () => addContextRepo,
+  formatSize: () => formatSize,
+  getContextSummary: () => getContextSummary,
+  readContextIndex: () => readContextIndex,
+  reindexContext: () => reindexContext,
+  removeContextRepo: () => removeContextRepo,
+  walkDirectory: () => walkDirectory,
+  writeContextIndex: () => writeContextIndex
+});
+import fs12 from "fs";
+import path12 from "path";
+import { parse as parse4, stringify as stringify6 } from "yaml";
+function getContextPath(projectDir) {
+  return path12.join(projectDir, CONTEXT_DIR, CONTEXT_FILE);
+}
+function emptyIndex() {
+  return { version: 1, repos: [] };
+}
+function readContextIndex(projectDir = process.cwd()) {
+  const filePath = getContextPath(projectDir);
+  try {
+    const raw = fs12.readFileSync(filePath, "utf-8");
+    const data = parse4(raw);
+    return data ?? emptyIndex();
+  } catch {
+    return emptyIndex();
+  }
+}
+function writeContextIndex(index, projectDir = process.cwd()) {
+  const dirPath = path12.join(projectDir, CONTEXT_DIR);
+  fs12.mkdirSync(dirPath, { recursive: true });
+  const filePath = getContextPath(projectDir);
+  fs12.writeFileSync(filePath, stringify6(index), "utf-8");
+}
+function walkDirectory(dirPath) {
+  const files = [];
+  function walk(currentPath) {
+    let entries;
+    try {
+      entries = fs12.readdirSync(currentPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && IGNORED_DIRS.has(entry.name)) continue;
+      if (IGNORED_DIRS.has(entry.name)) continue;
+      const fullPath = path12.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path12.extname(entry.name).toLowerCase();
+        if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
+        try {
+          const stat = fs12.statSync(fullPath);
+          const relativePath = path12.relative(dirPath, fullPath);
+          files.push({
+            path: relativePath,
+            extension: ext,
+            size: stat.size,
+            modified_at: stat.mtime.toISOString()
+          });
+        } catch {
+        }
       }
     }
-  },
-  blank() {
-    if (capturing) {
-      captured.push("");
-    } else {
-      console.log();
+  }
+  walk(dirPath);
+  return files;
+}
+function addContextRepo(repoPath, options = {}) {
+  const projectDir = options.projectDir ?? process.cwd();
+  const absolutePath = path12.resolve(projectDir, repoPath);
+  if (!fs12.existsSync(absolutePath)) {
+    throw new Error(`Directory not found: ${repoPath}`);
+  }
+  if (!fs12.statSync(absolutePath).isDirectory()) {
+    throw new Error(`Not a directory: ${repoPath}`);
+  }
+  const index = readContextIndex(projectDir);
+  const relative = path12.relative(projectDir, absolutePath);
+  const isInsideProject = !relative.startsWith("..") && !path12.isAbsolute(relative);
+  const storedPath = isInsideProject ? relative : absolutePath;
+  const existing = index.repos.find(
+    (r) => r.repo.path === storedPath || r.repo.name === options.name
+  );
+  if (existing) {
+    throw new Error(
+      `Context repo already exists: ${existing.repo.name ?? existing.repo.path}. Use \`planmode context reindex\` to refresh.`
+    );
+  }
+  logger.info(`Scanning ${absolutePath}...`);
+  const files = walkDirectory(absolutePath);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const repoIndex = {
+    repo: {
+      path: storedPath,
+      name: options.name,
+      added_at: now
+    },
+    files,
+    indexed_at: now,
+    file_count: files.length,
+    total_size: files.reduce((sum, f) => sum + f.size, 0)
+  };
+  index.repos.push(repoIndex);
+  writeContextIndex(index, projectDir);
+  logger.success(`Added "${options.name ?? storedPath}" \u2014 ${files.length} file(s), ${formatSize(repoIndex.total_size)}`);
+  const breakdown = getTypeBreakdown(files);
+  if (breakdown.length > 0) {
+    logger.dim(`  ${breakdown.join(", ")}`);
+  }
+  return repoIndex;
+}
+function removeContextRepo(pathOrName, projectDir = process.cwd()) {
+  const index = readContextIndex(projectDir);
+  const idx = index.repos.findIndex(
+    (r) => r.repo.path === pathOrName || r.repo.name === pathOrName
+  );
+  if (idx === -1) {
+    throw new Error(`Context repo not found: ${pathOrName}`);
+  }
+  const removed = index.repos[idx];
+  index.repos.splice(idx, 1);
+  writeContextIndex(index, projectDir);
+  logger.success(`Removed "${removed.repo.name ?? removed.repo.path}"`);
+}
+function reindexContext(pathOrName, projectDir = process.cwd()) {
+  const index = readContextIndex(projectDir);
+  if (index.repos.length === 0) {
+    throw new Error("No context repos configured. Use `planmode context add <path>` first.");
+  }
+  const targets = pathOrName ? index.repos.filter(
+    (r) => r.repo.path === pathOrName || r.repo.name === pathOrName
+  ) : index.repos;
+  if (pathOrName && targets.length === 0) {
+    throw new Error(`Context repo not found: ${pathOrName}`);
+  }
+  for (const repo of targets) {
+    const absolutePath = path12.resolve(projectDir, repo.repo.path);
+    if (!fs12.existsSync(absolutePath)) {
+      logger.warn(`Directory not found, skipping: ${repo.repo.path}`);
+      continue;
     }
+    logger.info(`Re-scanning ${repo.repo.name ?? repo.repo.path}...`);
+    const files = walkDirectory(absolutePath);
+    repo.files = files;
+    repo.indexed_at = (/* @__PURE__ */ new Date()).toISOString();
+    repo.file_count = files.length;
+    repo.total_size = files.reduce((sum, f) => sum + f.size, 0);
+    logger.success(`Reindexed "${repo.repo.name ?? repo.repo.path}" \u2014 ${files.length} file(s), ${formatSize(repo.total_size)}`);
   }
-};
+  writeContextIndex(index, projectDir);
+}
+function getContextSummary(projectDir = process.cwd()) {
+  const index = readContextIndex(projectDir);
+  return {
+    totalRepos: index.repos.length,
+    totalFiles: index.repos.reduce((sum, r) => sum + r.file_count, 0),
+    totalSize: index.repos.reduce((sum, r) => sum + r.total_size, 0),
+    repos: index.repos.map((r) => ({
+      name: r.repo.name ?? r.repo.path,
+      path: r.repo.path,
+      fileCount: r.file_count,
+      totalSize: r.total_size,
+      typeBreakdown: getTypeBreakdown(r.files),
+      indexedAt: r.indexed_at
+    }))
+  };
+}
+function getTypeBreakdown(files) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    counts.set(file.extension, (counts.get(file.extension) ?? 0) + 1);
+  }
+  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1]).map(([ext, count]) => `${ext}: ${count}`);
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+var CONTEXT_DIR, CONTEXT_FILE, SUPPORTED_EXTENSIONS, IGNORED_DIRS;
+var init_context = __esm({
+  "src/lib/context.ts"() {
+    "use strict";
+    init_logger();
+    CONTEXT_DIR = ".planmode";
+    CONTEXT_FILE = "context.yaml";
+    SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".txt",
+      ".md",
+      ".markdown",
+      ".pdf",
+      ".rtf",
+      ".doc",
+      ".docx",
+      ".csv",
+      ".tsv",
+      ".json",
+      ".yaml",
+      ".yml",
+      ".xml",
+      ".html",
+      ".htm",
+      ".rst",
+      ".org",
+      ".tex",
+      ".log"
+    ]);
+    IGNORED_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      ".next",
+      "__pycache__",
+      ".venv",
+      "venv",
+      ".tox",
+      "target",
+      "out",
+      ".cache",
+      ".turbo",
+      "coverage",
+      ".nyc_output"
+    ]);
+  }
+});
+
+// src/mcp.ts
+init_logger();
+import fs13 from "fs";
+import path13 from "path";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod/v4";
 
 // src/lib/registry.ts
 import fs2 from "fs";
@@ -651,6 +900,9 @@ function coerceValue(raw, def) {
   }
 }
 
+// src/lib/installer.ts
+init_logger();
+
 // src/lib/analytics.ts
 var API_BASE = "https://api.planmode.org";
 function trackDownload(packageName) {
@@ -1052,6 +1304,7 @@ function createPackage(options) {
 }
 
 // src/lib/publisher.ts
+init_logger();
 async function publishPackage(options = {}) {
   const cwd = options.projectDir ?? process.cwd();
   const interactive = options.interactive ?? false;
@@ -1852,6 +2105,7 @@ function detectCategory(data) {
 }
 
 // src/mcp.ts
+init_context();
 function withCapture(fn) {
   logger.capture();
   try {
@@ -2129,14 +2383,14 @@ server.registerTool(
       const entry = lockfile.packages[packageName];
       if (!entry) {
         const candidates = [
-          path12.join(dir, "plans", `${packageName}.md`),
-          path12.join(dir, ".claude", "rules", `${packageName}.md`),
-          path12.join(dir, "prompts", `${packageName}.md`)
+          path13.join(dir, "plans", `${packageName}.md`),
+          path13.join(dir, ".claude", "rules", `${packageName}.md`),
+          path13.join(dir, "prompts", `${packageName}.md`)
         ];
         for (const candidate of candidates) {
-          if (fs12.existsSync(candidate)) {
-            const content2 = fs12.readFileSync(candidate, "utf-8");
-            const relativePath = path12.relative(dir, candidate);
+          if (fs13.existsSync(candidate)) {
+            const content2 = fs13.readFileSync(candidate, "utf-8");
+            const relativePath = path13.relative(dir, candidate);
             return textResult(`# ${packageName}
 **Location:** ${relativePath}
 
@@ -2150,14 +2404,14 @@ ${content2}`);
           true
         );
       }
-      const fullPath = path12.join(dir, entry.installed_to);
-      if (!fs12.existsSync(fullPath)) {
+      const fullPath = path13.join(dir, entry.installed_to);
+      if (!fs13.existsSync(fullPath)) {
         return textResult(
           `Package '${packageName}' is in the lockfile but the file is missing at ${entry.installed_to}. Try reinstalling with planmode_install.`,
           true
         );
       }
-      const content = fs12.readFileSync(fullPath, "utf-8");
+      const content = fs13.readFileSync(fullPath, "utf-8");
       return textResult(
         `# ${packageName} (${entry.type} v${entry.version})
 **Location:** ${entry.installed_to}
@@ -2344,17 +2598,17 @@ server.registerTool(
   async ({ prompt: promptName, variables, projectDir }) => {
     try {
       const dir = projectDir ?? process.cwd();
-      const localPath = path12.join(dir, "prompts", `${promptName}.md`);
-      const localManifestPath = path12.join(dir, "prompts", promptName, "planmode.yaml");
+      const localPath = path13.join(dir, "prompts", `${promptName}.md`);
+      const localManifestPath = path13.join(dir, "prompts", promptName, "planmode.yaml");
       let content;
       let manifest;
-      if (fs12.existsSync(localManifestPath)) {
-        const raw = fs12.readFileSync(localManifestPath, "utf-8");
+      if (fs13.existsSync(localManifestPath)) {
+        const raw = fs13.readFileSync(localManifestPath, "utf-8");
         manifest = parseManifest(raw);
-        const promptDir = path12.join(dir, "prompts", promptName);
+        const promptDir = path13.join(dir, "prompts", promptName);
         content = readPackageContent(promptDir, manifest);
-      } else if (fs12.existsSync(localPath)) {
-        content = fs12.readFileSync(localPath, "utf-8");
+      } else if (fs13.existsSync(localPath)) {
+        content = fs13.readFileSync(localPath, "utf-8");
       } else {
         return textResult(
           `Prompt '${promptName}' not found locally. Install it first using the planmode_install tool.`,
@@ -2536,6 +2790,128 @@ server.registerTool(
     }
   }
 );
+server.registerTool(
+  "planmode_context_add",
+  {
+    description: "Add a document directory to the project context. Indexes all text-based files (md, pdf, txt, json, yaml, csv, html, etc.) and stores their metadata in .planmode/context.yaml. The AI can then see what documents are available and read them on demand.",
+    inputSchema: {
+      path: z.string().describe("Path to the document directory (relative to project or absolute)"),
+      name: z.string().optional().describe("Human-readable label for this directory"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ path: dirPath, name, projectDir }) => {
+    try {
+      const { result, messages } = withCapture(
+        () => addContextRepo(dirPath, { name, projectDir })
+      );
+      const breakdown = result.files.length > 0 ? `
+Types: ${getTypeBreakdownText(result)}` : "";
+      return textResult(
+        formatMessages(
+          messages,
+          `Added "${name ?? result.repo.path}" \u2014 ${result.file_count} file(s), ${formatSize(result.total_size)}${breakdown}`
+        )
+      );
+    } catch (err) {
+      return errorResult("Error adding context repo", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_context_remove",
+  {
+    description: "Remove a document directory from the project context",
+    inputSchema: {
+      pathOrName: z.string().describe("Path or name of the context repo to remove"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ pathOrName, projectDir }) => {
+    try {
+      const { messages } = withCapture(
+        () => removeContextRepo(pathOrName, projectDir)
+      );
+      return textResult(formatMessages(messages) || `Removed "${pathOrName}" from context.`);
+    } catch (err) {
+      return errorResult("Error removing context repo", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_context_list",
+  {
+    description: "List all document directories in the project context with file counts, sizes, and type breakdowns. Use this to see what reference documents are available for the project.",
+    inputSchema: {
+      detailed: z.boolean().optional().describe("Include full file listings for each repo (default: false, shows only summaries)"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ detailed, projectDir }) => {
+    try {
+      const summary = getContextSummary(projectDir);
+      if (summary.totalRepos === 0) {
+        return textResult("No context repos configured. Use planmode_context_add to add a document directory.");
+      }
+      const lines = [
+        `**${summary.totalRepos} context repo(s)** \u2014 ${summary.totalFiles} file(s), ${formatSize(summary.totalSize)}`,
+        ""
+      ];
+      for (const repo of summary.repos) {
+        lines.push(`### ${repo.name}`);
+        lines.push(`- **Path:** ${repo.path}`);
+        lines.push(`- **Files:** ${repo.fileCount} (${formatSize(repo.totalSize)})`);
+        if (repo.typeBreakdown.length > 0) {
+          lines.push(`- **Types:** ${repo.typeBreakdown.join(", ")}`);
+        }
+        lines.push(`- **Indexed:** ${repo.indexedAt}`);
+        if (detailed) {
+          const index = (await Promise.resolve().then(() => (init_context(), context_exports))).readContextIndex(projectDir);
+          const repoIndex = index.repos.find(
+            (r) => r.repo.path === repo.path || r.repo.name === repo.name
+          );
+          if (repoIndex && repoIndex.files.length > 0) {
+            lines.push("", "**Files:**");
+            for (const file of repoIndex.files) {
+              lines.push(`- \`${file.path}\` (${file.extension}, ${formatSize(file.size)})`);
+            }
+          }
+        }
+        lines.push("");
+      }
+      return textResult(lines.join("\n"));
+    } catch (err) {
+      return errorResult("Error listing context", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_context_reindex",
+  {
+    description: "Re-scan files in one or all context directories to update the file index",
+    inputSchema: {
+      pathOrName: z.string().optional().describe("Path or name of a specific repo to reindex (omit to reindex all)"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ pathOrName, projectDir }) => {
+    try {
+      const { messages } = withCapture(
+        () => reindexContext(pathOrName, projectDir)
+      );
+      return textResult(formatMessages(messages) || "Reindex complete.");
+    } catch (err) {
+      return errorResult("Error reindexing context", err);
+    }
+  }
+);
+function getTypeBreakdownText(repoIndex) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of repoIndex.files) {
+    counts.set(file.extension, (counts.get(file.extension) ?? 0) + 1);
+  }
+  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1]).map(([ext, count]) => `${ext}: ${count}`).join(", ");
+}
 server.registerResource(
   "installed-packages",
   new ResourceTemplate("planmode://packages/{name}", {
@@ -2568,10 +2944,10 @@ server.registerResource(
         }]
       };
     }
-    const fullPath = path12.join(process.cwd(), entry.installed_to);
+    const fullPath = path13.join(process.cwd(), entry.installed_to);
     let content;
     try {
-      content = fs12.readFileSync(fullPath, "utf-8");
+      content = fs13.readFileSync(fullPath, "utf-8");
     } catch {
       content = `File not found at ${entry.installed_to}. The package may need to be reinstalled.`;
     }