md4ai 0.9.5 → 0.9.7

package/dist/index.bundled.js

@@ -233,6 +233,7 @@ import { resolve as resolve2, dirname, join as join2 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 async function parseFileReferences(filePath, projectRoot) {
   const refs = [];
+  const brokenRefs = [];
   const content = await readFile2(filePath, "utf-8");
   const relPath = filePath.startsWith(projectRoot) ? filePath.slice(projectRoot.length + 1) : filePath;
   const markdownLinkPattern = /\[.*?\]\(([^)]+)\)/g;
@@ -251,23 +252,40 @@ async function parseFileReferences(filePath, projectRoot) {
       const target = match[1];
       if (!target || target.startsWith("http") || target.startsWith("#"))
         continue;
+      const baseName = target.split("/").pop() ?? target;
+      if (!target.includes("/") && /^[A-Z]/.test(baseName))
+        continue;
       const resolved = resolveTarget(target, filePath, projectRoot);
       if (resolved && existsSync2(resolved)) {
         addRef(refs, relPath, resolved, projectRoot);
+      } else if (resolved) {
+        const targetRel = resolved.startsWith(projectRoot) ? resolved.slice(projectRoot.length + 1) : resolved;
+        if (targetRel !== relPath) {
+          brokenRefs.push({ from: relPath, to: targetRel, rawRef: target });
+        }
       }
     }
   }
   if (filePath.endsWith(".json")) {
-    parseJsonPathReferences(content, relPath, projectRoot, refs);
+    parseJsonPathReferences(content, relPath, projectRoot, refs, brokenRefs);
   }
   const seen = /* @__PURE__ */ new Set();
-  return refs.filter((r) => {
+  const dedupedRefs = refs.filter((r) => {
     const key = `${r.from}->${r.to}`;
     if (seen.has(key))
       return false;
     seen.add(key);
     return true;
   });
+  const brokenSeen = /* @__PURE__ */ new Set();
+  const dedupedBroken = brokenRefs.filter((r) => {
+    const key = `${r.from}->${r.to}`;
+    if (brokenSeen.has(key))
+      return false;
+    brokenSeen.add(key);
+    return true;
+  });
+  return { refs: dedupedRefs, brokenRefs: dedupedBroken };
 }
 function resolveTarget(target, sourceFilePath, projectRoot) {
   if (target.startsWith("~")) {
@@ -279,6 +297,11 @@ function resolveTarget(target, sourceFilePath, projectRoot) {
   if (target.startsWith(".claude/") || target.startsWith("docs/")) {
     return join2(projectRoot, target);
   }
+  if (target.includes("/")) {
+    const fromRoot = join2(projectRoot, target);
+    if (existsSync2(fromRoot))
+      return fromRoot;
+  }
   return resolve2(dirname(sourceFilePath), target);
 }
 function addRef(refs, fromRel, resolvedAbsolute, projectRoot) {
@@ -287,7 +310,7 @@ function addRef(refs, fromRel, resolvedAbsolute, projectRoot) {
     refs.push({ from: fromRel, to: targetRel });
   }
 }
-function parseJsonPathReferences(content, fromRel, projectRoot, refs) {
+function parseJsonPathReferences(content, fromRel, projectRoot, refs, brokenRefs) {
   let parsed;
   try {
     parsed = JSON.parse(content);
@@ -304,6 +327,8 @@ function parseJsonPathReferences(content, fromRel, projectRoot, refs) {
         const resolved = join2(projectRoot, relTarget);
         if (existsSync2(resolved)) {
           addRef(refs, fromRel, resolved, projectRoot);
+        } else {
+          brokenRefs.push({ from: fromRel, to: relTarget, rawRef: relTarget });
         }
       }
     }
@@ -316,6 +341,8 @@ function parseJsonPathReferences(content, fromRel, projectRoot, refs) {
       const resolved = join2(projectRoot, target);
       if (existsSync2(resolved)) {
         addRef(refs, fromRel, resolved, projectRoot);
+      } else {
+        brokenRefs.push({ from: fromRel, to: target, rawRef: target });
       }
     }
   });
@@ -1259,11 +1286,13 @@ async function scanProject(projectRoot) {
   const allFiles = await discoverFiles(projectRoot);
   const rootFiles = identifyRoots(allFiles, projectRoot);
   const allRefs = [];
+  const allBrokenRefs = [];
   for (const file of allFiles) {
     const fullPath = file.startsWith("/") ? file : join10(projectRoot, file);
     try {
-      const refs = await parseFileReferences(fullPath, projectRoot);
+      const { refs, brokenRefs: brokenRefs2 } = await parseFileReferences(fullPath, projectRoot);
       allRefs.push(...refs);
+      allBrokenRefs.push(...brokenRefs2);
     } catch {
     }
   }
@@ -1273,11 +1302,32 @@ async function scanProject(projectRoot) {
   const skills = await parseSkills(projectRoot);
   const toolings = await detectToolings(projectRoot);
   const envManifest = await scanEnvManifest(projectRoot);
-  const scanData = JSON.stringify({ graph, orphans, skills, staleFiles, toolings, envManifest });
+  const depthMap = /* @__PURE__ */ new Map();
+  const queue = [...rootFiles];
+  for (const r of queue)
+    depthMap.set(r, 0);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const currentDepth = depthMap.get(current);
+    for (const ref of allRefs) {
+      if (ref.from === current && !depthMap.has(ref.to)) {
+        depthMap.set(ref.to, currentDepth + 1);
+        queue.push(ref.to);
+      }
+    }
+  }
+  const filteredBroken = allBrokenRefs.filter((br) => classifyFileType(br.from) !== "plan");
+  const brokenRefs = filteredBroken.map((br) => ({
+    ...br,
+    depth: depthMap.get(br.from) ?? 999
+  }));
+  brokenRefs.sort((a, b) => a.depth - b.depth || a.from.localeCompare(b.from));
+  const scanData = JSON.stringify({ graph, orphans, brokenRefs, skills, staleFiles, toolings, envManifest });
   const dataHash = createHash("sha256").update(scanData).digest("hex");
   return {
     graph,
     orphans,
+    brokenRefs,
     skills,
     staleFiles,
     toolings,
@@ -1595,7 +1645,7 @@ var CURRENT_VERSION;
 var init_check_update = __esm({
   "dist/check-update.js"() {
     "use strict";
-    CURRENT_VERSION = true ? "0.9.5" : "0.0.0-dev";
+    CURRENT_VERSION = true ? "0.9.7" : "0.0.0-dev";
   }
 });
 
@@ -1764,12 +1814,23 @@ async function mapCommand(path, options) {
   const result = await scanProject(projectRoot);
   console.log(`  Files found:   ${result.graph.nodes.length}`);
   console.log(`  References:    ${result.graph.edges.length}`);
+  console.log(`  Broken refs:   ${result.brokenRefs.length}`);
   console.log(`  Orphans:       ${result.orphans.length}`);
   console.log(`  Stale files:   ${result.staleFiles.length}`);
   console.log(`  Skills:        ${result.skills.length}`);
   console.log(`  Toolings:      ${result.toolings.length}`);
   console.log(`  Env Vars:      ${result.envManifest?.variables.length ?? 0} (${result.envManifest ? "manifest found" : "no manifest"})`);
   console.log(`  Data hash:     ${result.dataHash.slice(0, 12)}...`);
+  if (result.brokenRefs.length > 0) {
+    console.log(chalk11.red(`
+  Warning: ${result.brokenRefs.length} broken reference(s) found:`));
+    for (const br of result.brokenRefs.slice(0, 5)) {
+      console.log(chalk11.red(`    ${br.from} -> ${br.to}`));
+    }
+    if (result.brokenRefs.length > 5) {
+      console.log(chalk11.red(`    ... and ${result.brokenRefs.length - 5} more`));
+    }
+  }
   const outputDir = resolve3(projectRoot, "output");
   if (!existsSync7(outputDir)) {
     await mkdir2(outputDir, { recursive: true });
@@ -1823,6 +1884,7 @@ ${proposedFiles.length} file(s) proposed for deletion:
         const { error } = await supabase.from("claude_folders").update({
           graph_json: result.graph,
           orphans_json: result.orphans,
+          broken_refs_json: result.brokenRefs,
           skills_table_json: result.skills,
           stale_files_json: result.staleFiles,
           env_manifest_json: result.envManifest,
@@ -1914,6 +1976,7 @@ ${proposedFiles.length} file(s) proposed for deletion:
           await sb.from("claude_folders").update({
             graph_json: result.graph,
             orphans_json: result.orphans,
+            broken_refs_json: result.brokenRefs,
             skills_table_json: result.skills,
             stale_files_json: result.staleFiles,
             env_manifest_json: result.envManifest,
@@ -1989,6 +2052,7 @@ async function syncCommand(options) {
         await supabase.from("claude_folders").update({
           graph_json: result.graph,
           orphans_json: result.orphans,
+          broken_refs_json: result.brokenRefs,
           skills_table_json: result.skills,
           stale_files_json: result.staleFiles,
           env_manifest_json: result.envManifest,
@@ -2024,6 +2088,7 @@ async function syncCommand(options) {
     await supabase.from("claude_folders").update({
       graph_json: result.graph,
       orphans_json: result.orphans,
+      broken_refs_json: result.brokenRefs,
       skills_table_json: result.skills,
       stale_files_json: result.staleFiles,
       last_scanned: result.scannedAt,
@@ -2651,6 +2716,7 @@ async function checkPendingRescans(supabase, deviceId, deviceName) {
       await supabase.from("claude_folders").update({
         graph_json: result.graph,
         orphans_json: result.orphans,
+        broken_refs_json: result.brokenRefs,
         skills_table_json: result.skills,
         stale_files_json: result.staleFiles,
         env_manifest_json: result.envManifest,
@@ -3066,6 +3132,7 @@ Linking "${folder.name}" to this device...
   const { error: scanErr } = await supabase.from("claude_folders").update({
     graph_json: result.graph,
     orphans_json: result.orphans,
+    broken_refs_json: result.brokenRefs,
     skills_table_json: result.skills,
     stale_files_json: result.staleFiles,
     env_manifest_json: result.envManifest,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "md4ai",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "CLI for MD4AI — scan Claude projects and sync to your dashboard",
   "type": "module",
   "bin": {