facult 1.0.3 → 1.2.0

package/src/snippets.ts

@@ -230,6 +230,12 @@ export interface SyncResult {
   errors: string[];
 }
 
+export interface RenderSnippetTextResult {
+  text: string;
+  changes: SyncChange[];
+  errors: string[];
+}
+
 function isSafePathString(p: string): boolean {
   // Protect filesystem APIs from null-byte paths.
   return !p.includes("\0");
@@ -564,6 +570,106 @@ export async function syncFile(args: {
   return { filePath, dryRun, changed: true, changes, errors: [] };
 }
 
+export async function renderSnippetText(args: {
+  text: string;
+  project?: string | null;
+  filePath?: string;
+  rootDir?: string;
+}): Promise<RenderSnippetTextResult> {
+  const rootDir = args.rootDir ?? facultRootDir();
+  const text = args.text;
+  const filePath = args.filePath;
+  const errors: string[] = [];
+  const changes: SyncChange[] = [];
+
+  if (!hasMarkers(text)) {
+    return { text, changes, errors };
+  }
+
+  const found = findMarkersInText(text, filePath);
+  if (found.errors.length) {
+    return {
+      text,
+      changes,
+      errors: found.errors,
+    };
+  }
+
+  let lastEnd = -1;
+  for (const p of found.pairs) {
+    if (p.open.start < lastEnd) {
+      const location = filePath
+        ? `${filePath}:${p.open.line}`
+        : `line ${p.open.line}`;
+      errors.push(
+        `${location}: snippet markers may not be nested or overlapping (found ${p.name})`
+      );
+    }
+    lastEnd = p.close.end;
+  }
+  if (errors.length) {
+    return { text, changes, errors };
+  }
+
+  type Replacement = { start: number; end: number; next: string };
+  const replacements: Replacement[] = [];
+
+  for (const pair of found.pairs) {
+    const marker = pair.name;
+    const existing = text.slice(pair.contentStart, pair.contentEnd);
+    const existingNorm = normalizeSnippetBody(existing);
+
+    const snippet = await findSnippet({
+      marker,
+      project: args.project ?? null,
+      rootDir,
+    });
+
+    if (!snippet) {
+      changes.push({ marker, status: "not-found" });
+      continue;
+    }
+
+    const snippetNorm = normalizeSnippetBody(snippet.content);
+    if (existingNorm === snippetNorm) {
+      changes.push({
+        marker,
+        status: "unchanged",
+        snippetPath: snippet.path,
+        lines: countLines(snippetNorm),
+      });
+      continue;
+    }
+
+    replacements.push({
+      start: pair.contentStart,
+      end: pair.contentEnd,
+      next: formatSnippetInjection(snippet.content),
+    });
+    changes.push({
+      marker,
+      status: "updated",
+      snippetPath: snippet.path,
+      lines: countLines(snippetNorm),
+    });
+  }
+
+  if (replacements.length === 0) {
+    return { text, changes, errors };
+  }
+
+  let updated = text;
+  for (const r of replacements.sort((a, b) => b.start - a.start)) {
+    updated = updated.slice(0, r.start) + r.next + updated.slice(r.end);
+  }
+
+  return {
+    text: updated,
+    changes,
+    errors,
+  };
+}
+
 export async function syncAll(args?: {
   dryRun?: boolean;
   /** Override canonical root (useful for tests). */

package/src/trust-list.ts

@@ -226,6 +226,7 @@ export async function applyOrgTrustList(
     },
     agents: index.agents ?? {},
     snippets: index.snippets ?? {},
+    instructions: index.instructions ?? {},
   };
 
   return next;

package/src/trust.ts

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { ensureAiIndexPath } from "./ai-state";
 import type { FacultIndex } from "./index-builder";
-import { facultRootDir } from "./paths";
+import { facultAiIndexPath, facultRootDir } from "./paths";
 
 type TrustMode = "trust" | "untrust";
 
@@ -17,6 +17,7 @@ function ensureIndexStructure(index: FacultIndex): FacultIndex {
     mcp: index.mcp ?? { servers: {} },
     agents: index.agents ?? {},
     snippets: index.snippets ?? {},
+    instructions: index.instructions ?? {},
   };
 }
 
@@ -27,8 +28,12 @@ function parseEntryName(raw: string): { kind: "skill" | "mcp"; name: string } {
   return { kind: "skill", name: raw };
 }
 
-async function loadIndex(rootDir: string): Promise<FacultIndex> {
-  const indexPath = join(rootDir, "index.json");
+async function loadIndex(homeDir: string): Promise<FacultIndex> {
+  const { path: indexPath } = await ensureAiIndexPath({
+    homeDir,
+    rootDir: facultRootDir(homeDir),
+    repair: true,
+  });
   const file = Bun.file(indexPath);
   if (!(await file.exists())) {
     throw new Error(`Index not found at ${indexPath}. Run "facult index".`);
@@ -37,8 +42,8 @@ async function loadIndex(rootDir: string): Promise<FacultIndex> {
   return JSON.parse(raw) as FacultIndex;
 }
 
-async function writeIndex(rootDir: string, index: FacultIndex) {
-  const indexPath = join(rootDir, "index.json");
+async function writeIndex(homeDir: string, index: FacultIndex) {
+  const indexPath = facultAiIndexPath(homeDir);
   await Bun.write(indexPath, `${JSON.stringify(index, null, 2)}\n`);
 }
 
@@ -68,20 +73,17 @@ export async function applyTrust({
   names,
   mode,
   homeDir,
-  rootDir,
 }: {
   names: string[];
   mode: TrustMode;
   homeDir?: string;
-  rootDir?: string;
 }) {
   if (!names.length) {
     throw new Error("At least one name is required.");
   }
   const home = homeDir ?? homedir();
-  const root = rootDir ?? facultRootDir(home);
 
-  const index = ensureIndexStructure(await loadIndex(root));
+  const index = ensureIndexStructure(await loadIndex(home));
   const now = new Date().toISOString();
 
   const missing: string[] = [];
@@ -109,7 +111,7 @@ export async function applyTrust({
   }
 
   index.updatedAt = new Date().toISOString();
-  await writeIndex(root, index);
+  await writeIndex(home, index);
 }
 
 function parseNamesFromArgv(argv: string[]): string[] {