@swarmvaultai/engine 3.16.0 → 3.17.0

package/dist/index.js

@@ -121,6 +121,7 @@ import {
   searchVault,
   stageGeneratedOutputPages,
   startMemoryTask,
+  syncTrackedFiles,
   syncTrackedRepos,
   syncTrackedReposForWatch,
   updateMemoryTask,
@@ -130,7 +131,7 @@ import {
   writeGuidedSourceSession,
   writeRetrievalManifest,
   writeWatchStatusArtifact
-} from "./chunk-TQIIJVVG.js";
+} from "./chunk-JEWLYIHN.js";
 import {
   LocalWhisperProviderAdapter,
   SWARMVAULT_OUT_ENV,
@@ -1235,6 +1236,68 @@ async function predictRemovedSourceIdsFromRepoSync(rootDir, options) {
     )
   ];
 }
+var REFRESH_LOCK_DIRNAME = "refresh.lock";
+var REFRESH_QUEUE_FILENAME = "refresh-queue.json";
+var REFRESH_LOCK_STALE_MS = 10 * 6e4;
+var MAX_FILE_REFRESH_ROUNDS = 5;
+function refreshLockDir(watchDir) {
+  return path4.join(watchDir, REFRESH_LOCK_DIRNAME);
+}
+async function tryAcquireRefreshLock(watchDir) {
+  const lockDir = refreshLockDir(watchDir);
+  await fs4.mkdir(watchDir, { recursive: true });
+  const writeOwner = () => fs4.writeFile(
+    path4.join(lockDir, "owner.json"),
+    `${JSON.stringify({ pid: process2.pid, acquiredAt: (/* @__PURE__ */ new Date()).toISOString() })}
+`,
+    "utf8"
+  );
+  try {
+    await fs4.mkdir(lockDir, { recursive: false });
+    await writeOwner();
+    return true;
+  } catch {
+    try {
+      const stat = await fs4.stat(lockDir);
+      if (Date.now() - stat.mtimeMs > REFRESH_LOCK_STALE_MS) {
+        await fs4.rm(lockDir, { recursive: true, force: true });
+        await fs4.mkdir(lockDir, { recursive: false });
+        await writeOwner();
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+async function releaseRefreshLock(watchDir) {
+  await fs4.rm(refreshLockDir(watchDir), { recursive: true, force: true });
+}
+async function enqueueRefreshFiles(watchDir, files) {
+  await fs4.mkdir(watchDir, { recursive: true });
+  const queuePath = path4.join(watchDir, REFRESH_QUEUE_FILENAME);
+  let existing = [];
+  try {
+    const parsed = JSON.parse(await fs4.readFile(queuePath, "utf8"));
+    if (Array.isArray(parsed)) {
+      existing = parsed.filter((entry) => typeof entry === "string");
+    }
+  } catch {
+  }
+  const merged = [.../* @__PURE__ */ new Set([...existing, ...files])];
+  await fs4.writeFile(queuePath, `${JSON.stringify(merged, null, 2)}
+`, "utf8");
+}
+async function drainRefreshQueue(watchDir) {
+  const queuePath = path4.join(watchDir, REFRESH_QUEUE_FILENAME);
+  try {
+    const parsed = JSON.parse(await fs4.readFile(queuePath, "utf8"));
+    await fs4.rm(queuePath, { force: true });
+    return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
+  } catch {
+    return [];
+  }
+}
 function hasIgnoredRepoSegment(baseDir, targetPath) {
   const relativePath = path4.relative(baseDir, targetPath);
   if (!relativePath || relativePath.startsWith("..")) {
@@ -1369,8 +1432,128 @@ async function performWatchCycle(rootDir, paths, options, codeOnly = false) {
     lintFindingCount
   };
 }
+async function runFileRefreshCycle(rootDir, paths, options, files) {
+  const resolvedFiles = [...new Set(files.map((candidate) => path4.resolve(rootDir, candidate)))];
+  const emptyResult = {
+    watchedRepoRoots: [],
+    importedCount: 0,
+    scannedCount: 0,
+    attachmentCount: 0,
+    repoImportedCount: 0,
+    repoUpdatedCount: 0,
+    repoRemovedCount: 0,
+    repoScannedCount: 0,
+    pendingSemanticRefreshCount: 0,
+    pendingSemanticRefreshPaths: [],
+    changedPages: []
+  };
+  if (!await tryAcquireRefreshLock(paths.watchDir)) {
+    await enqueueRefreshFiles(paths.watchDir, resolvedFiles);
+    return { ...emptyResult, queuedFiles: resolvedFiles };
+  }
+  const startedAt = /* @__PURE__ */ new Date();
+  const reasons = resolvedFiles.map((file) => `file:${path4.relative(rootDir, file) || file}`);
+  let success = true;
+  let error;
+  const result = { ...emptyResult };
+  try {
+    const seenRoots = /* @__PURE__ */ new Set();
+    const changedPages = /* @__PURE__ */ new Set();
+    let pendingFiles = resolvedFiles;
+    let rounds = 0;
+    while (pendingFiles.length > 0 && rounds < MAX_FILE_REFRESH_ROUNDS) {
+      rounds += 1;
+      const repoSync = await syncTrackedFiles(rootDir, pendingFiles);
+      const compile = await compileVault(rootDir, { codeOnly: true });
+      const pendingSemanticRefresh = await mergePendingSemanticRefresh(rootDir, repoSync.pendingSemanticRefresh);
+      const stalePagePaths = await markPagesStaleForSources(
+        rootDir,
+        pendingSemanticRefresh.map((entry) => entry.sourceId).filter((sourceId) => Boolean(sourceId))
+      );
+      for (const repoRoot of repoSync.repoRoots) {
+        seenRoots.add(repoRoot);
+      }
+      for (const page of [...compile.changedPages, ...stalePagePaths]) {
+        changedPages.add(page);
+      }
+      result.scannedCount += repoSync.scannedCount;
+      result.repoScannedCount += repoSync.scannedCount;
+      result.repoImportedCount += repoSync.imported.length;
+      result.repoUpdatedCount += repoSync.updated.length;
+      result.repoRemovedCount += repoSync.removed.length;
+      result.pendingSemanticRefreshCount = pendingSemanticRefresh.length;
+      result.pendingSemanticRefreshPaths = pendingSemanticRefresh.map((entry) => entry.path);
+      pendingFiles = await drainRefreshQueue(paths.watchDir);
+    }
+    if (pendingFiles.length > 0) {
+      await enqueueRefreshFiles(paths.watchDir, pendingFiles);
+      result.queuedFiles = pendingFiles;
+    }
+    result.watchedRepoRoots = [...seenRoots].sort((left, right) => left.localeCompare(right));
+    result.changedPages = [...changedPages];
+    if (options.lint) {
+      result.lintFindingCount = (await lintVault(rootDir)).length;
+    }
+    return result;
+  } catch (caught) {
+    success = false;
+    error = caught instanceof Error ? caught.message : String(caught);
+    throw caught;
+  } finally {
+    await releaseRefreshLock(paths.watchDir);
+    const finishedAt = /* @__PURE__ */ new Date();
+    const runSummary = {
+      startedAt: startedAt.toISOString(),
+      finishedAt: finishedAt.toISOString(),
+      durationMs: finishedAt.getTime() - startedAt.getTime(),
+      inputDir: paths.inboxDir,
+      reasons,
+      importedCount: result.repoImportedCount + result.repoUpdatedCount,
+      scannedCount: result.scannedCount,
+      attachmentCount: 0,
+      changedPages: result.changedPages,
+      repoImportedCount: result.repoImportedCount,
+      repoUpdatedCount: result.repoUpdatedCount,
+      repoRemovedCount: result.repoRemovedCount,
+      repoScannedCount: result.repoScannedCount,
+      pendingSemanticRefreshCount: result.pendingSemanticRefreshCount,
+      pendingSemanticRefreshPaths: result.pendingSemanticRefreshPaths,
+      lintFindingCount: result.lintFindingCount,
+      success,
+      error
+    };
+    await recordSession(rootDir, {
+      operation: "watch",
+      title: `File refresh for ${reasons.join(", ")}`,
+      startedAt: startedAt.toISOString(),
+      finishedAt: finishedAt.toISOString(),
+      success,
+      error,
+      changedPages: result.changedPages,
+      lintFindingCount: result.lintFindingCount,
+      lines: [
+        `reasons=${reasons.join(",")}`,
+        `repo_imported=${result.repoImportedCount}`,
+        `repo_updated=${result.repoUpdatedCount}`,
+        `repo_removed=${result.repoRemovedCount}`,
+        `pending_semantic_refresh=${result.pendingSemanticRefreshCount}`,
+        `lint=${result.lintFindingCount ?? 0}`
+      ]
+    });
+    await appendWatchRun(rootDir, runSummary);
+    await writeWatchStatusArtifact(rootDir, {
+      generatedAt: finishedAt.toISOString(),
+      watchedRepoRoots: result.watchedRepoRoots,
+      lastRun: runSummary,
+      pendingSemanticRefresh: await readPendingSemanticRefresh(rootDir)
+    });
+  }
+}
 async function runWatchCycle(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
+  if (options.files && options.files.length > 0) {
+    return runFileRefreshCycle(rootDir, paths, options, options.files);
+  }
   const previousGraph = await readJsonFile(paths.graphPath);
   const startedAt = /* @__PURE__ */ new Date();
   let success = true;
@@ -3509,8 +3692,26 @@ function renderHtmlStandalone(graph) {
       var seedPageIds = coreUnique(matches.filter(function(m) { return m.type === "page"; }).map(function(m) { return m.id; }));
       var visitedEdgeIdList = Object.keys(visitedEdgeIds);
 
+      var topMatchParts = matches.slice(0, 8).map(function(m) {
+        var pagePath;
+        if (m.type === "page") {
+          pagePath = (CORE_PAGE_BY_ID[m.id] && CORE_PAGE_BY_ID[m.id].path) || m.id;
+        } else if (m.type === "node") {
+          var matchNode = CORE_NODE_BY_ID[m.id];
+          var matchPageId = matchNode && matchNode.pageId;
+          if (matchPageId) pagePath = (CORE_PAGE_BY_ID[matchPageId] && CORE_PAGE_BY_ID[matchPageId].path) || matchPageId;
+        }
+        return (m.label || m.id) + " (" + m.type + ", score " + m.score + (pagePath ? ", page " + pagePath : "") + ")";
+      });
+      var topMatchesLine = matches.length
+        ? "Top matches: " + topMatchParts.join("; ") + (matches.length > 8 ? " (+" + (matches.length - 8) + " more)" : "")
+        : "Top matches: none";
+      var seedsLine = seeds.length
+        ? "Seeds: " + seeds.slice(0, 15).join(", ") + (seeds.length > 15 ? " (+" + (seeds.length - 15) + " more)" : "")
+        : "Seeds: none";
       var summary = [
-        "Seeds: " + (seeds.join(", ") || "none"),
+        topMatchesLine,
+        seedsLine,
         "Visited nodes: " + visitedNodeIds.length,
         "Visited edges: " + visitedEdgeIdList.length,
         "Touched group patterns: " + hyperedgeIds.length,
@@ -5510,7 +5711,7 @@ 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";
-var SERVER_VERSION = "3.16.0";
+var SERVER_VERSION = "3.17.0";
 var codeLanguageSchema = z.enum([
   "javascript",
   "jsx",
@@ -6175,6 +6376,38 @@ async function createMcpServer(rootDir) {
       return asToolText(status);
     })
   );
+  server.registerTool(
+    "graph_status",
+    {
+      description: "Read-only graph freshness check: graph/report presence, tracked repo changes since the last refresh, and the recommended refresh command.",
+      inputSchema: {
+        repoRoots: z.array(z.string()).optional().describe("Optional repo roots to check instead of configured/tracked roots")
+      }
+    },
+    safeHandler(async ({ repoRoots }) => {
+      const status = await getGraphStatus(rootDir, { repoRoots });
+      return asToolText(status);
+    })
+  );
+  server.registerTool(
+    "update_graph",
+    {
+      description: "Code-only graph refresh. With files, refreshes just those files (fast path used after edits); otherwise walks tracked repo roots.",
+      inputSchema: {
+        files: z.array(z.string()).optional().describe("Refresh only these files instead of walking every tracked repo root"),
+        force: z.boolean().optional().describe("Allow updates even when node or edge counts shrink sharply")
+      }
+    },
+    safeHandler(async ({ files, force }) => {
+      const result = await runWatchCycle(rootDir, {
+        repo: true,
+        codeOnly: true,
+        force: force ?? false,
+        files: files?.length ? files : void 0
+      });
+      return asToolText(result);
+    })
+  );
   server.registerTool(
     "consolidate",
     {
@@ -6438,6 +6671,12 @@ var PROVIDER_TASK_KEYS = [
   "embeddingProvider",
   "audioProvider"
 ];
+var REQUIRED_PROVIDER_TASK_KEYS = /* @__PURE__ */ new Set([
+  "compileProvider",
+  "queryProvider",
+  "lintProvider",
+  "visionProvider"
+]);
 async function loadRawConfig(rootDir) {
   await initWorkspace(rootDir);
   const { paths } = await loadVaultConfig(rootDir);
@@ -6538,24 +6777,42 @@ async function removeProviderConfig(options) {
   const tasks = ensureTasks(raw);
   const removed = Boolean(providers[options.providerId]);
   delete providers[options.providerId];
+  if (options.fallbackProviderId && !providers[options.fallbackProviderId]) {
+    throw new Error(`Provider ${options.fallbackProviderId} is not configured; cannot reassign tasks to it.`);
+  }
   const fallbackProviderId = options.fallbackProviderId ?? (providers.local ? "local" : Object.keys(providers).sort((left, right) => left.localeCompare(right))[0]);
-  const updatedTasks = [];
-  for (const taskKey of PROVIDER_TASK_KEYS) {
-    if (tasks[taskKey] === options.providerId) {
-      if (!fallbackProviderId) {
-        delete tasks[taskKey];
-      } else {
-        tasks[taskKey] = fallbackProviderId;
-      }
-      updatedTasks.push(taskKey);
+  const assignedTaskKeys = PROVIDER_TASK_KEYS.filter((taskKey) => tasks[taskKey] === options.providerId);
+  if (!fallbackProviderId) {
+    const orphanedRequired = assignedTaskKeys.filter((taskKey) => REQUIRED_PROVIDER_TASK_KEYS.has(taskKey));
+    if (orphanedRequired.length) {
+      throw new Error(
+        `Cannot remove provider ${options.providerId}; tasks ${orphanedRequired.join(", ")} would have no provider. Configure another provider first or pass a fallback.`
+      );
     }
   }
-  await writeJsonFile(configPath, raw);
+  const reassignedTasks = [];
+  const clearedTasks = [];
+  for (const taskKey of assignedTaskKeys) {
+    if (!fallbackProviderId) {
+      delete tasks[taskKey];
+      clearedTasks.push(taskKey);
+    } else {
+      tasks[taskKey] = fallbackProviderId;
+      reassignedTasks.push(taskKey);
+    }
+  }
+  const updatedTasks = assignedTaskKeys;
+  if (removed || updatedTasks.length) {
+    await writeJsonFile(configPath, raw);
+  }
   return {
     providerId: options.providerId,
     configPath,
     removed,
-    updatedTasks
+    fallbackProviderId: fallbackProviderId ?? null,
+    updatedTasks,
+    reassignedTasks,
+    clearedTasks
   };
 }
 
@@ -9905,6 +10162,7 @@ export {
   startMcpServer,
   startMemoryTask,
   summarizeLocalWhisperSetup,
+  syncTrackedFiles,
   syncTrackedRepos,
   syncTrackedReposForWatch,
   synthesizeHyperedgeHubs,

package/dist/memory-GFOW2QWQ.js

@@ -0,0 +1,32 @@
+import {
+  buildMemoryGraphElements,
+  ensureMemoryLedger,
+  estimateMemoryTaskTokens,
+  finishMemoryTask,
+  listMemoryTasks,
+  loadMemoryTaskPages,
+  memoryTaskHashes,
+  memoryTaskPageRecord,
+  readMemoryTask,
+  renderMemoryTaskMarkdown,
+  resumeMemoryTask,
+  startMemoryTask,
+  updateMemoryTask
+} from "./chunk-VSDBQVSE.js";
+import "./chunk-NON6BVEI.js";
+import "./chunk-NAIERP4C.js";
+export {
+  buildMemoryGraphElements,
+  ensureMemoryLedger,
+  estimateMemoryTaskTokens,
+  finishMemoryTask,
+  listMemoryTasks,
+  loadMemoryTaskPages,
+  memoryTaskHashes,
+  memoryTaskPageRecord,
+  readMemoryTask,
+  renderMemoryTaskMarkdown,
+  resumeMemoryTask,
+  startMemoryTask,
+  updateMemoryTask
+};

package/dist/memory-GSCQ6F53.js

@@ -0,0 +1,32 @@
+import {
+  buildMemoryGraphElements,
+  ensureMemoryLedger,
+  estimateMemoryTaskTokens,
+  finishMemoryTask,
+  listMemoryTasks,
+  loadMemoryTaskPages,
+  memoryTaskHashes,
+  memoryTaskPageRecord,
+  readMemoryTask,
+  renderMemoryTaskMarkdown,
+  resumeMemoryTask,
+  startMemoryTask,
+  updateMemoryTask
+} from "./chunk-HORJDLXV.js";
+import "./chunk-NON6BVEI.js";
+import "./chunk-NAIERP4C.js";
+export {
+  buildMemoryGraphElements,
+  ensureMemoryLedger,
+  estimateMemoryTaskTokens,
+  finishMemoryTask,
+  listMemoryTasks,
+  loadMemoryTaskPages,
+  memoryTaskHashes,
+  memoryTaskPageRecord,
+  readMemoryTask,
+  renderMemoryTaskMarkdown,
+  resumeMemoryTask,
+  startMemoryTask,
+  updateMemoryTask
+};

package/dist/memory-HMP3Y4PQ.js

@@ -0,0 +1,32 @@
+import {
+  buildMemoryGraphElements,
+  ensureMemoryLedger,
+  estimateMemoryTaskTokens,
+  finishMemoryTask,
+  listMemoryTasks,
+  loadMemoryTaskPages,
+  memoryTaskHashes,
+  memoryTaskPageRecord,
+  readMemoryTask,
+  renderMemoryTaskMarkdown,
+  resumeMemoryTask,
+  startMemoryTask,
+  updateMemoryTask
+} from "./chunk-65IRGGXX.js";
+import "./chunk-NON6BVEI.js";
+import "./chunk-NAIERP4C.js";
+export {
+  buildMemoryGraphElements,
+  ensureMemoryLedger,
+  estimateMemoryTaskTokens,
+  finishMemoryTask,
+  listMemoryTasks,
+  loadMemoryTaskPages,
+  memoryTaskHashes,
+  memoryTaskPageRecord,
+  readMemoryTask,
+  renderMemoryTaskMarkdown,
+  resumeMemoryTask,
+  startMemoryTask,
+  updateMemoryTask
+};

package/dist/memory-PQWSJ4RR.js

@@ -0,0 +1,32 @@
+import {
+  buildMemoryGraphElements,
+  ensureMemoryLedger,
+  estimateMemoryTaskTokens,
+  finishMemoryTask,
+  listMemoryTasks,
+  loadMemoryTaskPages,
+  memoryTaskHashes,
+  memoryTaskPageRecord,
+  readMemoryTask,
+  renderMemoryTaskMarkdown,
+  resumeMemoryTask,
+  startMemoryTask,
+  updateMemoryTask
+} from "./chunk-JEWLYIHN.js";
+import "./chunk-NON6BVEI.js";
+import "./chunk-NAIERP4C.js";
+export {
+  buildMemoryGraphElements,
+  ensureMemoryLedger,
+  estimateMemoryTaskTokens,
+  finishMemoryTask,
+  listMemoryTasks,
+  loadMemoryTaskPages,
+  memoryTaskHashes,
+  memoryTaskPageRecord,
+  readMemoryTask,
+  renderMemoryTaskMarkdown,
+  resumeMemoryTask,
+  startMemoryTask,
+  updateMemoryTask
+};