@north-light/crouter 0.3.154

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/frontmatter-rules/test.ts

@@ -0,0 +1,119 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import frontmatterRules from "./index.ts";
+
+// ---- Tiny mock harness -----------------------------------------------------
+type Handler = (event: any, ctx: any) => Promise<any>;
+function makePi() {
+	const handlers: Record<string, Handler> = {};
+	const pi: any = { on: (name: string, h: Handler) => (handlers[name] = h) };
+	return { pi, handlers };
+}
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "fmr-test-"));
+const ctx = { cwd: tmp, hasUI: false };
+
+function rule(rel: string, content: string) {
+	const fp = path.join(tmp, rel);
+	fs.mkdirSync(path.dirname(fp), { recursive: true });
+	fs.writeFileSync(fp, content);
+}
+function doc(rel: string, content: string) {
+	const fp = path.join(tmp, rel);
+	fs.mkdirSync(path.dirname(fp), { recursive: true });
+	fs.writeFileSync(fp, content);
+	return fp;
+}
+
+// Rules at project root .pi/rules
+rule(".pi/rules/security.md", `---\nname: Security review\nwhen:\n  tags: { contains: security }\n---\nDo a threat model.`);
+rule(".pi/rules/spec.md", `---\nwhen:\n  type: spec\n---\nFollow the spec checklist.`);
+rule(".pi/rules/high-prio-api.md", `---\nname: High prio API\nwhen:\n  all:\n    - type: spec\n    - priority: { gte: 3 }\n  any:\n    - { area: api }\n    - { tags: { containsAny: [api, http] } }\n---\nGet API review.`);
+rule(".pi/rules/inert.md", `---\nname: No condition\n---\nThis should never auto-load.`);
+rule(".pi/rules/nested-field.md", `---\nwhen:\n  meta.owner: alice\n---\nPing alice.`);
+rule(".pi/rules/regex.md", `---\nwhen:\n  title: { imatches: "^api[- ]" }\n---\nName matched regex.`);
+// A deeper rules dir that should NOT apply to a file above it
+rule("sub/.pi/rules/deep.md", `---\nwhen:\n  type: spec\n---\nDeep rule.`);
+
+const { pi, handlers } = makePi();
+frontmatterRules(pi);
+
+let pass = 0;
+let fail = 0;
+async function check(name: string, filePath: string, expectRules: string[], notExpect: string[] = [], freshSeen = true) {
+	if (freshSeen) await handlers["session_start"]({}, ctx); // reset dedup
+	const event = {
+		toolName: "read",
+		isError: false,
+		input: { path: filePath },
+		content: [{ type: "text", text: "FILE_BODY" }],
+	};
+	const res = await handlers["tool_result"](event, ctx);
+	const text: string = res?.content?.[0]?.text ?? "";
+	const ok =
+		expectRules.every((r) => text.includes(r)) &&
+		notExpect.every((r) => !text.includes(r)) &&
+		(expectRules.length === 0 ? res === undefined : true);
+	if (ok) {
+		pass++;
+		console.log(`  ok  ${name}`);
+	} else {
+		fail++;
+		console.log(`FAIL  ${name}`);
+		console.log(`      expected: ${JSON.stringify(expectRules)} absent: ${JSON.stringify(notExpect)}`);
+		console.log(`      got:\n${text.split("\n").map((l) => "        " + l).join("\n")}`);
+	}
+}
+
+(async () => {
+	// 1. array `contains` on tags
+	await check("tags contains security", doc("a.md", `---\ntags: [security, infra]\n---\nbody`), ["Security review"], ["spec", "High prio"]);
+
+	// 2. scalar equality on type
+	await check("type spec equality", doc("b.md", `---\ntype: spec\n---\nbody`), ["Follow the spec checklist"], ["Security review"]);
+
+	// 3. combinator all+any with gte and containsAny
+	await check("complex all/any/gte", doc("c.md", `---\ntype: spec\npriority: 4\ntags: [http]\n---\nbody`),
+		["High prio API", "Follow the spec checklist"]);
+
+	// 4. complex should fail when priority too low
+	await check("complex fails low priority", doc("d.md", `---\ntype: spec\npriority: 1\narea: api\n---\nbody`),
+		["Follow the spec checklist"], ["High prio API"]);
+
+	// 5. inert rule never loads; no frontmatter match at all -> undefined result
+	await check("no matching frontmatter -> no injection", doc("e.md", `---\nrandom: value\n---\nbody`), []);
+
+	// 6. nested dotted field
+	await check("nested dotted field", doc("f.md", `---\nmeta:\n  owner: alice\n---\nbody`), ["Ping alice"]);
+
+	// 7. case-insensitive regex
+	await check("imatches regex", doc("g.md", `---\ntitle: "API Gateway"\n---\nbody`), ["Name matched regex"]);
+
+	// 8. file with NO frontmatter -> skip entirely
+	await check("no frontmatter -> skip", doc("h.md", `# just a heading\nno frontmatter`), []);
+
+	// 9. deep rule applies to files in its subtree
+	await check("deep rule in subtree", doc("sub/deep-doc.md", `---\ntype: spec\n---\nbody`),
+		["Deep rule", "Follow the spec checklist"]);
+
+	// 10. deep rule does NOT apply to files above it (file at root)
+	await check("deep rule not above", doc("top.md", `---\ntype: spec\n---\nbody`),
+		["Follow the spec checklist"], ["Deep rule"]);
+
+	// 11. dedup across reads within a session (no fresh seen): second matching read injects nothing
+	await handlers["session_start"]({}, ctx);
+	await check("dedup first read", doc("dq1.md", `---\ntype: spec\n---\nbody`), ["Follow the spec checklist"], [], false);
+	await check("dedup second read (already seen)", doc("dq2.md", `---\ntype: spec\n---\nbody`), [], [], false);
+
+	// 12. non-markdown read ignored
+	const tsEvent = { toolName: "read", isError: false, input: { path: doc("x.ts", "const a=1;") }, content: [{ type: "text", text: "x" }] };
+	await handlers["session_start"]({}, ctx);
+	const tsRes = await handlers["tool_result"](tsEvent, ctx);
+	if (tsRes === undefined) { pass++; console.log("  ok  non-markdown ignored"); }
+	else { fail++; console.log("FAIL  non-markdown ignored"); }
+
+	console.log(`\n${pass} passed, ${fail} failed`);
+	fs.rmSync(tmp, { recursive: true, force: true });
+	process.exit(fail === 0 ? 0 : 1);
+})();

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/memory-slash-commands.ts

@@ -0,0 +1,195 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readFileSync } from "node:fs";
+import { parse as parseYaml } from "yaml";
+import {
+  expandDeterministicCommand,
+  type DeterministicCommandExpansion,
+} from "../../../core/runtime/command-expansion.js";
+
+const exec = promisify(execFile);
+const CRTR = "crtr";
+
+// ---------------------------------------------------------------------------
+// memory-slash-commands: any memory doc frontmatter-flagged `slash: true`
+// becomes an invocable slash command (`/<name>`). This mirrors Hermes Agent's
+// "every skill is automatically a slash command" — /research-alpha injects
+// the doc body (plus the user's free-text args) as a normal turn instead of
+// requiring a separate skill-invocation mechanism.
+//
+// Discovery shells out to `crtr memory list --json --paths`, which already
+// resolves the substrate's scope precedence (project stack > profile > user >
+// builtin) — this file does not walk memory/ directories or reimplement scope
+// resolution. `list`'s JSON items are already scope-precedence sorted (see
+// `scopeRank` in crouter's memory/shared.ts), so first-occurrence-wins per doc
+// name reproduces the resolver's identity precedence for free. `list` is
+// bounded/paginated, so discovery pages through the full corpus via
+// `next_cursor` until exhausted, and passes `--paths` because `path` is
+// load-bearing here (isSlashFlagged reads the file at each item's path).
+// ---------------------------------------------------------------------------
+
+const FRONTMATTER_RE = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?/;
+
+interface MemoryListItem {
+  name: string;
+  path: string;
+  short_form: string;
+  is_dir: boolean;
+}
+
+export interface SlashDoc {
+  /** Path-derived doc name, e.g. "research-alpha" or "taste/foo" — what
+   *  `crtr memory read` resolves. */
+  name: string;
+  /** `name` with `/` -> `:` — the registered command name (a flat name is
+   *  unchanged). */
+  commandName: string;
+  /** The memory document's short-form description, shown in the slash menu. */
+  description: string;
+}
+
+interface MemoryListPage {
+  items: MemoryListItem[];
+  next_cursor: string | null;
+}
+
+async function defaultListMemoryDocs(): Promise<MemoryListItem[]> {
+  const items: MemoryListItem[] = [];
+  let cursor: string | undefined;
+  for (;;) {
+    const args = ["memory", "list", "--json", "--paths", "--limit", "200"];
+    if (cursor !== undefined) args.push("--cursor", cursor);
+    const { stdout } = await exec(CRTR, args, { maxBuffer: 8 * 1024 * 1024 });
+    const parsed = JSON.parse(stdout) as MemoryListPage;
+    items.push(...parsed.items);
+    if (parsed.next_cursor === null) break;
+    cursor = parsed.next_cursor;
+  }
+  return items;
+}
+
+async function defaultReadMemoryDoc(name: string): Promise<string> {
+  const { stdout } = await exec(CRTR, ["memory", "read", name, "--json"], { maxBuffer: 8 * 1024 * 1024 });
+  const parsed = JSON.parse(stdout) as { content: string };
+  return parsed.content;
+}
+
+let listMemoryDocsImpl = defaultListMemoryDocs;
+let readMemoryDocImpl = defaultReadMemoryDoc;
+
+/** Test seam: override doc discovery so tests never shell out to `crtr`. */
+export function __setListMemoryDocsForTest(fn?: typeof listMemoryDocsImpl): void {
+  listMemoryDocsImpl = fn ?? defaultListMemoryDocs;
+}
+
+/** Test seam: override doc-body reads so tests never shell out to `crtr`. */
+export function __setReadMemoryDocForTest(fn?: typeof readMemoryDocImpl): void {
+  readMemoryDocImpl = fn ?? defaultReadMemoryDoc;
+}
+
+/** Read a memory doc's raw frontmatter directly off its already-resolved
+ *  `path` (from `crtr memory list`) and report whether `slash` is `true`.
+ *  No directory walk, no scope reasoning — the path is already resolved. */
+function isSlashFlagged(path: string): boolean {
+  let raw: string;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return false;
+  }
+  const match = raw.match(FRONTMATTER_RE);
+  if (!match) return false;
+  let data: unknown;
+  try {
+    data = parseYaml(match[1]);
+  } catch {
+    return false;
+  }
+  if (data === null || typeof data !== "object" || Array.isArray(data)) return false;
+  return (data as Record<string, unknown>).slash === true;
+}
+
+/** `/`-joined path-derived doc name -> the registered slash-command name. */
+export function slashCommandName(docName: string): string {
+  return docName.split("/").join(":");
+}
+
+/** Every `slash: true` memory doc, scope-precedence-deduped by name (see
+ *  module header). Directory INDEX entries never register as commands. A doc
+ *  without `slash` (or `slash: false`) is silently excluded. */
+export async function discoverSlashDocs(): Promise<SlashDoc[]> {
+  let items: MemoryListItem[];
+  try {
+    items = await listMemoryDocsImpl();
+  } catch {
+    return [];
+  }
+  const seen = new Set<string>();
+  const out: SlashDoc[] = [];
+  for (const item of items) {
+    if (item.is_dir) continue;
+    if (seen.has(item.name)) continue;
+    seen.add(item.name);
+    if (isSlashFlagged(item.path)) {
+      out.push({ name: item.name, commandName: slashCommandName(item.name), description: item.short_form });
+    }
+  }
+  return out;
+}
+
+/** Compose the invocation prompt from the freshly-read doc body plus the
+ *  user's raw invocation args, following Claude Code's `$ARGUMENTS`
+ *  convention. When the body contains `$ARGUMENTS`, every occurrence is
+ *  replaced with the trimmed args (empty string when none were given) and the
+ *  substituted body is injected AS-IS — the doc placed its own args, so no
+ *  extra header is added. Otherwise: a short invocation header naming the
+ *  command and the raw args (both the given-args and no-args cases are
+ *  load-bearing, per the Hermes /learn prompt pattern this mirrors), followed
+ *  by the full doc body as the instructions to follow. */
+export function composeSlashPrompt(commandName: string, rawArgs: string, body: string): string {
+  return expandDeterministicCommand({ kind: "memory-slash", commandName, body }, rawArgs);
+}
+
+export default async function (pi: ExtensionAPI) {
+  const docs = await discoverSlashDocs();
+  for (const doc of docs) {
+    let expansion: DeterministicCommandExpansion | undefined;
+    let loadError: unknown;
+    try {
+      expansion = {
+        kind: "memory-slash",
+        commandName: doc.commandName,
+        body: await readMemoryDocImpl(doc.name),
+      };
+    } catch (err) {
+      loadError = err;
+    }
+
+    // pi preserves unknown registration fields on the resolved command object.
+    // The broker discloses this serializable contract through get_commands; the
+    // handler below consumes the SAME object and expander, so preview cannot
+    // drift from submission. A failed/dynamic command has no expansion metadata.
+    pi.registerCommand(doc.commandName, {
+      description: doc.description,
+      ...(expansion === undefined ? {} : { expansion }),
+      handler: async (args, ctx) => {
+        if (expansion === undefined) {
+          ctx.ui.notify(
+            `/${doc.commandName}: failed to read memory doc "${doc.name}": ${loadError instanceof Error ? loadError.message : String(loadError)}`,
+            "error",
+          );
+          return;
+        }
+        pi.sendMessage(
+          {
+            customType: "memory-slash-command",
+            content: expandDeterministicCommand(expansion, args ?? ""),
+            display: true,
+          },
+          { triggerTurn: true },
+        );
+      },
+    } as Parameters<ExtensionAPI["registerCommand"]>[1] & { expansion?: DeterministicCommandExpansion });
+  }
+}