@rubytech/create-realagent 1.0.870 → 1.0.871

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/create-realagent",
-  "version": "1.0.870",
+  "version": "1.0.871",
   "description": "Install Real Agent — Built for agents. By agents.",
   "bin": {
     "create-realagent": "./dist/index.js"

package/payload/platform/scripts/__tests__/admin-persist-audit.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Task 943 — admin-persist-audit.
+ *
+ * Pins Task 940 success criterion #7: the audit harness counts JSONL
+ * assistant turns + render-component blocks against Neo4j `:Message` +
+ * `:Component` rows for a `conversationId`, prints one
+ *
+ *   [admin-persist-audit] convId=<conv> sdkTurnUuid=<uuid> expected=<message|component> missing reason=neo4j-row-absent
+ *
+ * line per divergence, and exits non-zero on mismatch.
+ *
+ * The test mocks the Neo4j surface (`getRecentMessages`, `getSession`) so
+ * `runAudit` is a pure function of (JSONL fixture, Neo4j seed). The
+ * harness reads the fixture with the real `replayJsonl`, so the matching
+ * key (role + content) is verified end-to-end without a graph connection.
+ */
+import { resolve } from "node:path";
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const FIXTURE_PATH = resolve(__dirname, "../../ui/app/lib/__tests__/fixtures/task-940-session.jsonl");
+
+// Mock the Neo4j surface. The audit harness imports `getRecentMessages`
+// and `getSession` from `platform/ui/app/lib/neo4j-store`. We replace
+// both with vi-managed fakes; each test reseeds them as needed.
+const getRecentMessagesMock = vi.fn<[string, number?], Promise<Array<{
+  role: "user" | "assistant";
+  content: string;
+  messageId: string;
+  components?: Array<{ componentId: string; submitted: boolean }>;
+}>>>();
+
+const sessionRunMock = vi.fn<[string, Record<string, unknown>], Promise<{
+  records: Array<{ get(key: string): unknown }>;
+}>>();
+const sessionCloseMock = vi.fn<[], Promise<void>>();
+
+vi.mock("../../ui/app/lib/neo4j-store", () => ({
+  getRecentMessages: (...args: Parameters<typeof getRecentMessagesMock>) => getRecentMessagesMock(...args),
+  getSession: () => ({
+    run: (cypher: string, params: Record<string, unknown>) => sessionRunMock(cypher, params),
+    close: () => sessionCloseMock(),
+  }),
+}));
+
+vi.mock("../../ui/app/lib/claude-agent/account", () => ({
+  ACCOUNTS_DIR: "/tmp/maxy-accounts-fixture",
+}));
+
+// PERSISTENT_COMPONENTS is also imported by the audit harness for the
+// :KnowledgeDocument projection check. We mock the set so the test does
+// not depend on the runtime persistent-component list — the fixture
+// components (`document-editor`, `quick-chart`) are both included.
+vi.mock("../../lib/persistent-components/src/index", () => ({
+  PERSISTENT_COMPONENTS: new Set<string>(["document-editor", "quick-chart"]),
+  isPersistentComponent: (name: string) => name === "document-editor" || name === "quick-chart",
+}));
+
+import { runAudit, type AuditArgs } from "../admin-persist-audit";
+
+const CONV_ID = "11111111-aaaa-bbbb-cccc-dddddddddddd";
+const ACCOUNT_ID = "b3b638d9-9999-8888-7777-666666666666";
+
+const buildArgs = (): AuditArgs => ({
+  conversationId: CONV_ID,
+  accountId: ACCOUNT_ID,
+  jsonlPath: FIXTURE_PATH,
+});
+
+const captureConsole = () => {
+  const out: string[] = [];
+  const err: string[] = [];
+  const logSpy = vi.spyOn(console, "log").mockImplementation((...a) => { out.push(a.join(" ")); });
+  const errSpy = vi.spyOn(console, "error").mockImplementation((...a) => { err.push(a.join(" ")); });
+  return { out, err, restore: () => { logSpy.mockRestore(); errSpy.mockRestore(); } };
+};
+
+describe("Task 940 SC7 — admin-persist-audit divergence reporting", () => {
+  beforeEach(() => {
+    getRecentMessagesMock.mockReset();
+    sessionRunMock.mockReset();
+    sessionCloseMock.mockReset();
+    sessionCloseMock.mockResolvedValue(undefined);
+  });
+
+  it("Neo4j seed missing the assistant turn (and its components) → exit=1, one missing-message line + one missing-component line per component", async () => {
+    // Fixture has 1 user + 1 assistant (with 2 components). Seed Neo4j
+    // with the user only — the assistant turn is the silent persist
+    // failure the audit must surface.
+    getRecentMessagesMock.mockResolvedValue([
+      { role: "user", content: "Please render the doc and a chart.", messageId: "neo4j-user", components: [] },
+    ]);
+    // No persistent-component rows in Neo4j (since the assistant turn
+    // never persisted). The :KnowledgeDocument check finds nothing → no
+    // additional kd-absent divergences.
+    sessionRunMock.mockResolvedValue({ records: [] });
+
+    const cap = captureConsole();
+    try {
+      const code = await runAudit(buildArgs());
+      expect(code).toBe(1);
+
+      // One divergence line for the assistant message itself…
+      const messageMisses = cap.out.filter((l) => /expected=message missing reason=neo4j-row-absent/.test(l));
+      expect(messageMisses).toHaveLength(1);
+      expect(messageMisses[0]).toMatch(/sdkTurnUuid=22222222/); // matches fixture uuid prefix
+
+      // …plus one divergence line per component sibling that was queued
+      // by the assistant turn's render-component blocks.
+      const componentMisses = cap.out.filter((l) => /expected=component .* missing reason=neo4j-row-absent/.test(l));
+      expect(componentMisses).toHaveLength(2);
+      expect(componentMisses[0]).toMatch(/component_name=document-editor ordinal=0/);
+      expect(componentMisses[1]).toMatch(/component_name=quick-chart ordinal=1/);
+
+      // Status summary line ends with status=mismatch.
+      expect(cap.out.some((l) => /status=mismatch/.test(l))).toBe(true);
+    } finally {
+      cap.restore();
+    }
+  });
+
+  it("Neo4j seed in lockstep with JSONL → exit=0, status=ok, zero divergence lines", async () => {
+    getRecentMessagesMock.mockResolvedValue([
+      { role: "user", content: "Please render the doc and a chart.", messageId: "neo4j-user", components: [] },
+      {
+        role: "assistant",
+        content: "Here is the doc.\n\nAnd a chart follows.",
+        messageId: "neo4j-asst",
+        components: [
+          { componentId: "comp-doc", submitted: false },
+          { componentId: "comp-chart", submitted: false },
+        ],
+      },
+    ]);
+    // Persistent-component KD projection: both rows have a sibling
+    // :KnowledgeDocument row → no kd-absent divergences.
+    sessionRunMock.mockResolvedValue({
+      records: [
+        { get: (k: string) => ({ componentId: "comp-doc", componentName: "document-editor", accountId: ACCOUNT_ID, attachmentId: "att-doc", hasProjection: true })[k] },
+        { get: (k: string) => ({ componentId: "comp-chart", componentName: "quick-chart", accountId: ACCOUNT_ID, attachmentId: "att-chart", hasProjection: true })[k] },
+      ],
+    });
+
+    const cap = captureConsole();
+    try {
+      const code = await runAudit(buildArgs());
+      expect(code).toBe(0);
+      expect(cap.out.some((l) => /divergences=0 status=ok/.test(l))).toBe(true);
+      expect(cap.out.some((l) => /missing reason=neo4j-row-absent/.test(l))).toBe(false);
+    } finally {
+      cap.restore();
+    }
+  });
+
+  it("Neo4j throw on getRecentMessages → exit=2 (invocation error), no divergence lines", async () => {
+    getRecentMessagesMock.mockRejectedValue(new Error("bolt://neo4j unreachable"));
+    sessionRunMock.mockResolvedValue({ records: [] });
+
+    const cap = captureConsole();
+    try {
+      const code = await runAudit(buildArgs());
+      expect(code).toBe(2);
+      expect(cap.err.some((l) => /neo4j-read-failed/.test(l) && /bolt:\/\/neo4j unreachable/.test(l))).toBe(true);
+    } finally {
+      cap.restore();
+    }
+  });
+
+  it("JSONL absent → exit=2 (invocation error)", async () => {
+    const cap = captureConsole();
+    try {
+      const code = await runAudit({
+        conversationId: CONV_ID,
+        accountId: ACCOUNT_ID,
+        jsonlPath: resolve(__dirname, "fixtures/does-not-exist.jsonl"),
+      });
+      expect(code).toBe(2);
+      expect(cap.err.some((l) => /jsonl absent path=/.test(l))).toBe(true);
+    } finally {
+      cap.restore();
+    }
+  });
+});

package/payload/platform/scripts/admin-persist-audit.ts

@@ -37,14 +37,19 @@ import { ACCOUNTS_DIR } from "../ui/app/lib/claude-agent/account";
 import { getRecentMessages, getSession } from "../ui/app/lib/neo4j-store";
 import { PERSISTENT_COMPONENTS } from "../lib/persistent-components/src/index";
 
-interface Args {
+// Task 943 — `AuditArgs` and `runAudit` are exported so the test
+// (`platform/scripts/__tests__/admin-persist-audit.test.ts`) can mock the
+// Neo4j surface and drive the audit with synthetic JSONL + Neo4j seeds,
+// verifying the divergence-line shape and non-zero exit code without
+// re-executing the live session or requiring a real graph connection.
+export interface AuditArgs {
   conversationId: string;
   accountId: string;
   jsonlPath: string;
 }
 
-function parseArgs(argv: string[]): Args | { error: string } {
-  const out: Partial<Args> = {};
+function parseArgs(argv: string[]): AuditArgs | { error: string } {
+  const out: Partial<AuditArgs> = {};
   let sessionId: string | undefined;
   let jsonlOverride: string | undefined;
   for (const a of argv) {
@@ -66,16 +71,11 @@ function parseArgs(argv: string[]): Args | { error: string } {
   } else {
     return { error: "either --jsonl or --session-id required" };
   }
-  return out as Args;
+  return out as AuditArgs;
 }
 
-async function main(): Promise<number> {
-  const parsed = parseArgs(process.argv.slice(2));
-  if ("error" in parsed) {
-    console.error(`[admin-persist-audit] usage error: ${parsed.error}`);
-    return 2;
-  }
-  const { conversationId, jsonlPath } = parsed;
+export async function runAudit(args: AuditArgs): Promise<number> {
+  const { conversationId, jsonlPath } = args;
 
   if (!existsSync(jsonlPath)) {
     console.error(`[admin-persist-audit] jsonl absent path=${jsonlPath} convId=${conversationId.slice(0, 8)}`);
@@ -183,9 +183,35 @@ async function main(): Promise<number> {
   return 1;
 }
 
-main()
-  .then((code) => process.exit(code))
-  .catch((err) => {
-    console.error(`[admin-persist-audit] crashed: ${err instanceof Error ? err.stack : String(err)}`);
-    process.exit(2);
-  });
+async function main(): Promise<number> {
+  const parsed = parseArgs(process.argv.slice(2));
+  if ("error" in parsed) {
+    console.error(`[admin-persist-audit] usage error: ${parsed.error}`);
+    return 2;
+  }
+  return runAudit(parsed);
+}
+
+// Task 943 — only invoke main() when this script is executed directly.
+// Importing the module (e.g. from `admin-persist-audit.test.ts`) reads
+// `runAudit` and `AuditArgs` without firing the top-level argv parser or
+// process.exit, which would otherwise kill the vitest worker before any
+// assertion ran. `import.meta.url` resolves to the script path under tsx;
+// the suffix check matches both the .ts source and any compiled .js output.
+const invokedDirectly = (() => {
+  try {
+    const entry = process.argv[1];
+    return typeof entry === "string" && import.meta.url.endsWith(entry.replace(/\\/g, "/").split("/").pop() ?? "");
+  } catch {
+    return false;
+  }
+})();
+
+if (invokedDirectly) {
+  main()
+    .then((code) => process.exit(code))
+    .catch((err) => {
+      console.error(`[admin-persist-audit] crashed: ${err instanceof Error ? err.stack : String(err)}`);
+      process.exit(2);
+    });
+}