facult 2.7.0 → 2.7.2

package/src/index-builder.ts

@@ -69,6 +69,12 @@ export interface AgentEntry {
   path: string;
   description?: string;
   lastModifiedAt?: string;
+  enabledFor?: string[];
+  trusted?: boolean;
+  trustedAt?: string;
+  trustedBy?: string;
+  auditStatus?: "pending" | "passed" | "flagged";
+  lastAuditAt?: string;
 }
 
 export interface SnippetEntry {
@@ -197,6 +203,53 @@ function extractIndexMeta(entry: unknown): {
   };
 }
 
+function findPreviousEntryByCanonicalRef(
+  previous: Record<string, unknown> | undefined,
+  canonicalRef: string | undefined,
+  fallbackName: string
+): unknown {
+  if (!previous) {
+    return undefined;
+  }
+  if (typeof canonicalRef === "string") {
+    for (const value of Object.values(previous)) {
+      if (!isPlainObject(value)) {
+        continue;
+      }
+      if (value.canonicalRef === canonicalRef) {
+        return value;
+      }
+    }
+  }
+  const legacyFallback = previous[fallbackName];
+  if (
+    isPlainObject(legacyFallback) &&
+    typeof legacyFallback.canonicalRef !== "string"
+  ) {
+    return legacyFallback;
+  }
+  return undefined;
+}
+
+function findPreviousMcpEntry(
+  previous: Record<string, unknown> | undefined,
+  canonicalRef: string | undefined,
+  name: string
+): unknown {
+  if (!previous) {
+    return undefined;
+  }
+  const candidate = previous[name];
+  if (!isPlainObject(candidate)) {
+    return undefined;
+  }
+  return typeof candidate.canonicalRef !== "string" ||
+    (typeof canonicalRef === "string" &&
+      candidate.canonicalRef === canonicalRef)
+    ? candidate
+    : undefined;
+}
+
 function stripQuotes(s: string): string {
   const t = s.trim();
   if (
@@ -489,8 +542,12 @@ async function indexSkills(
       const md = await Bun.file(skillMd).text();
       const { description, tags } = parseSkillMarkdown(md);
       const name = basename(d);
-
-      const prev = previous?.[name];
+      const canonicalRef = canonicalRefForPath(source, "skills", d);
+      const prev = findPreviousEntryByCanonicalRef(
+        previous,
+        canonicalRef,
+        name
+      );
       const meta = extractIndexMeta(prev);
 
       out[name] = {
@@ -498,7 +555,7 @@ async function indexSkills(
         path: d,
         description,
         tags,
-        canonicalRef: canonicalRefForPath(source, "skills", d),
+        canonicalRef,
         lastModifiedAt: await statIsoTime(skillMd),
         enabledFor: meta.enabledFor,
         trusted: meta.trusted ?? false,
@@ -550,12 +607,13 @@ async function indexMcpServers(
 
     const lm = await statIsoTime(mcpConfigPath);
     for (const name of Object.keys(serversObj).sort()) {
-      const prev = previous?.[name];
+      const canonicalRef = canonicalRefForPath(source, "mcp", mcpConfigPath);
+      const prev = findPreviousMcpEntry(previous, canonicalRef, name);
       const meta = extractIndexMeta(prev);
       out[name] = {
         name,
         path: mcpConfigPath,
-        canonicalRef: canonicalRefForPath(source, "mcp", mcpConfigPath),
+        canonicalRef,
         lastModifiedAt: lm,
         definition: serversObj[name],
         enabledFor: meta.enabledFor,
@@ -576,7 +634,8 @@ async function indexMcpServers(
 
 async function indexAgents(
   agentsDir: string,
-  source: IndexedSource
+  source: IndexedSource,
+  previous?: Record<string, unknown>
 ): Promise<Record<string, AgentEntry>> {
   const out: Record<string, AgentEntry> = {};
   const files: string[] = [];
@@ -596,6 +655,9 @@ async function indexAgents(
   for (const p of files) {
     const name =
       basename(p) === "agent.toml" ? basename(dirname(p)) : basename(p);
+    const canonicalRef = canonicalRefForPath(source, "agents", p);
+    const prev = findPreviousEntryByCanonicalRef(previous, canonicalRef, name);
+    const meta = extractIndexMeta(prev);
     let description: string | undefined;
     try {
       const raw = await Bun.file(p).text();
@@ -611,8 +673,14 @@ async function indexAgents(
       name,
       path: p,
       description,
-      canonicalRef: canonicalRefForPath(source, "agents", p),
+      canonicalRef,
       lastModifiedAt: await statIsoTime(p),
+      enabledFor: meta.enabledFor,
+      trusted: meta.trusted ?? false,
+      trustedAt: meta.trustedAt,
+      trustedBy: meta.trustedBy,
+      auditStatus: meta.auditStatus ?? "pending",
+      lastAuditAt: meta.lastAuditAt,
       ...entryScopeMeta(source),
     };
   }
@@ -782,6 +850,9 @@ async function indexSourceAssets(
   const prevSkills = isPlainObject(previousIndex?.skills)
     ? (previousIndex?.skills as Record<string, unknown>)
     : undefined;
+  const prevAgents = isPlainObject(previousIndex?.agents)
+    ? (previousIndex?.agents as Record<string, unknown>)
+    : undefined;
   const prevMcpMap =
     isPlainObject(previousIndex?.mcp) &&
     isPlainObject((previousIndex.mcp as Record<string, unknown>).servers)
@@ -795,7 +866,7 @@ async function indexSourceAssets(
     await Promise.all([
       indexSkills(skillsDir, source, prevSkills),
       indexMcpServers(canonicalMcpPath, source, prevMcpMap),
-      indexAgents(agentsDir, source),
+      indexAgents(agentsDir, source, prevAgents),
       indexSnippets(snippetsDir, source),
       indexInstructions(instructionsDir, source),
       indexToolAssets(toolsDir, source),

package/src/index.ts

@@ -1,10 +1,6 @@
 #!/usr/bin/env bun
 
 import { join } from "node:path";
-import { getAllAdapters } from "./adapters";
-import { aiCommand } from "./ai";
-import { auditCommand } from "./audit";
-import { autosyncCommand } from "./autosync";
 import {
   type CapabilityScopeMode,
   parseCliContextArgs,
@@ -20,9 +16,6 @@ import {
   renderPage,
   renderTable,
 } from "./cli-ui";
-import { consolidateCommand } from "./consolidate";
-import { doctorCommand } from "./doctor";
-import { disableCommand, enableCommand } from "./enable-disable";
 import type { AssetScope, AssetSourceKind } from "./graph";
 import {
   graphDependencies,
@@ -38,14 +31,6 @@ import type {
   SkillEntry,
   SnippetEntry,
 } from "./index-builder";
-import { indexCommand } from "./index-builder";
-import {
-  manageCommand,
-  managedCommand,
-  syncCommand,
-  unmanageCommand,
-} from "./manage";
-import { migrateCommand } from "./migrate";
 import type { QueryFilters } from "./query";
 import {
   filterAgents,
@@ -56,18 +41,6 @@ import {
   findCapabilities,
   loadIndex,
 } from "./query";
-import {
-  installCommand,
-  searchCommand,
-  sourcesCommand,
-  templatesCommand,
-  updateCommand,
-  verifySourceCommand,
-} from "./remote";
-import { scanCommand } from "./scan";
-import { selfUpdateCommand } from "./self-update";
-import { snippetsCommand } from "./snippets-cli";
-import { trustCommand, untrustCommand } from "./trust";
 import { parseJsonLenient } from "./util/json";
 
 type ListKind = "skills" | "mcp" | "agents" | "snippets" | "instructions";
@@ -1131,7 +1104,7 @@ async function graphCommand(argv: string[]) {
   }
 }
 
-function adaptersCommand(argv: string[]) {
+async function adaptersCommand(argv: string[]) {
   if (argv.includes("--help") || argv.includes("-h") || argv[0] === "help") {
     console.log(
       renderPage({
@@ -1147,6 +1120,7 @@ function adaptersCommand(argv: string[]) {
     );
     return;
   }
+  const { getAllAdapters } = await import("./adapters");
   const adapters = getAllAdapters();
   if (!adapters.length) {
     console.log(
@@ -1186,28 +1160,35 @@ async function main(argv: string[]) {
 
   // Convenience: allow `fclt --show-duplicates` as shorthand for `fclt scan --show-duplicates`.
   if (cmd === "--show-duplicates") {
+    const { scanCommand } = await import("./scan");
     await scanCommand([cmd, ...rest]);
     return;
   }
 
   switch (cmd) {
     case "scan":
-      await scanCommand(rest);
+      await import("./scan").then(({ scanCommand }) => scanCommand(rest));
       return;
     case "audit":
-      await auditCommand(rest);
+      await import("./audit").then(({ auditCommand }) => auditCommand(rest));
       return;
     case "migrate":
-      await migrateCommand(rest);
+      await import("./migrate").then(({ migrateCommand }) =>
+        migrateCommand(rest)
+      );
       return;
     case "doctor":
-      await doctorCommand(rest);
+      await import("./doctor").then(({ doctorCommand }) => doctorCommand(rest));
       return;
     case "consolidate":
-      await consolidateCommand(rest);
+      await import("./consolidate").then(({ consolidateCommand }) =>
+        consolidateCommand(rest)
+      );
       return;
     case "index":
-      await indexCommand(rest);
+      await import("./index-builder").then(({ indexCommand }) =>
+        indexCommand(rest)
+      );
       return;
     case "list":
       await listCommand(rest);
@@ -1222,65 +1203,91 @@ async function main(argv: string[]) {
       await graphCommand(rest);
       return;
     case "ai":
-      await aiCommand(rest);
+      await import("./ai").then(({ aiCommand }) => aiCommand(rest));
       return;
     case "adapters":
       await adaptersCommand(rest);
       return;
     case "trust":
-      await trustCommand(rest);
+      await import("./trust").then(({ trustCommand }) => trustCommand(rest));
       return;
     case "untrust":
-      await untrustCommand(rest);
+      await import("./trust").then(({ untrustCommand }) =>
+        untrustCommand(rest)
+      );
       return;
     case "manage":
-      await manageCommand(rest);
+      await import("./manage").then(({ manageCommand }) => manageCommand(rest));
       return;
     case "unmanage":
-      await unmanageCommand(rest);
+      await import("./manage").then(({ unmanageCommand }) =>
+        unmanageCommand(rest)
+      );
       return;
     case "managed":
-      await managedCommand(rest);
+      await import("./manage").then(({ managedCommand }) =>
+        managedCommand(rest)
+      );
       return;
     case "enable":
-      await enableCommand(rest);
+      await import("./enable-disable").then(({ enableCommand }) =>
+        enableCommand(rest)
+      );
       return;
     case "disable":
-      await disableCommand(rest);
+      await import("./enable-disable").then(({ disableCommand }) =>
+        disableCommand(rest)
+      );
       return;
     case "sync":
-      await syncCommand(rest);
+      await import("./manage").then(({ syncCommand }) => syncCommand(rest));
       return;
     case "autosync":
-      await autosyncCommand(rest);
+      await import("./autosync").then(({ autosyncCommand }) =>
+        autosyncCommand(rest)
+      );
       return;
     case "search":
-      await searchCommand(rest);
+      await import("./remote").then(({ searchCommand }) => searchCommand(rest));
       return;
     case "install":
-      await installCommand(rest);
+      await import("./remote").then(({ installCommand }) =>
+        installCommand(rest)
+      );
       return;
     case "update":
       if (rest.includes("--self")) {
-        await selfUpdateCommand(rest.filter((arg) => arg !== "--self"));
+        await import("./self-update").then(({ selfUpdateCommand }) =>
+          selfUpdateCommand(rest.filter((arg) => arg !== "--self"))
+        );
         return;
       }
-      await updateCommand(rest);
+      await import("./remote").then(({ updateCommand }) => updateCommand(rest));
       return;
     case "self-update":
-      await selfUpdateCommand(rest);
+      await import("./self-update").then(({ selfUpdateCommand }) =>
+        selfUpdateCommand(rest)
+      );
       return;
     case "verify-source":
-      await verifySourceCommand(rest);
+      await import("./remote").then(({ verifySourceCommand }) =>
+        verifySourceCommand(rest)
+      );
       return;
     case "templates":
-      await templatesCommand(rest);
+      await import("./remote").then(({ templatesCommand }) =>
+        templatesCommand(rest)
+      );
       return;
     case "sources":
-      await sourcesCommand(rest);
+      await import("./remote").then(({ sourcesCommand }) =>
+        sourcesCommand(rest)
+      );
       return;
     case "snippets":
-      await snippetsCommand(rest);
+      await import("./snippets-cli").then(({ snippetsCommand }) =>
+        snippetsCommand(rest)
+      );
       return;
     default:
       console.error(`Unknown command: ${cmd}`);