@tryinget/pi-agent-vent 0.1.2 → 0.2.1

package/tests/agent-vent-extension.test.js

@@ -1,17 +1,25 @@
+// ---
+// summary: tests agent_vent tool registration, commands, actions, and authority-safe output
+// read_when:
+//   - modifying the extension schema, command surface, lifecycle actions, or smoke contracts
+// ---
+
 import assert from "node:assert/strict";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
-import agentVentExtension from "../extensions/agent-vent.ts";
+import agentVentExtension, { _test } from "../extensions/agent-vent.ts";
 import { createCurationEvent, createVentRecord, readReviewEvents } from "../src/vent-store.js";
 
 function createMockPi() {
   const tools = new Map();
   const commands = new Map();
+  const messages = [];
   return {
     tools,
     commands,
+    messages,
     api: {
       registerTool(tool) {
         tools.set(tool.name, tool);
@@ -19,6 +27,9 @@ function createMockPi() {
       registerCommand(name, command) {
         commands.set(name, command);
       },
+      sendMessage(message) {
+        messages.push(message);
+      },
     },
   };
 }
@@ -39,6 +50,9 @@ test("agent_vent tool schema stays aligned with retention candidate and compare
   const schemaText = JSON.stringify(pi.tools.get("agent_vent").parameters);
 
   assert.match(schemaText, /"compare"/);
+  assert.match(schemaText, /"preview"/);
+  assert.match(schemaText, /"workflow_friction"/);
+  assert.match(schemaText, /"context_alignment"/);
   assert.match(schemaText, /"candidates"/);
   assert.match(schemaText, /"history"/);
   assert.match(schemaText, /retentionCandidateState/);
@@ -48,6 +62,41 @@ test("agent_vent tool schema stays aligned with retention candidate and compare
   assert.match(schemaText, /outcomes, compare, export, or retention planning/);
 });
 
+test("agent_vent keeps long command output persistent while short statuses stay notifications", async () => {
+  const pi = createMockPi();
+  agentVentExtension(pi.api);
+  const notifications = [];
+  const ctx = { hasUI: true, ui: { notify: (message) => notifications.push(message) } };
+
+  await pi.commands.get("agent_vent").handler("help", ctx);
+  assert.equal(pi.messages.length, 1);
+  assert.equal(pi.messages[0].customType, "agent-vent-command");
+  assert.match(pi.messages[0].content, /agent_vent commands/);
+  assert.match(notifications[0], /added to the session transcript/);
+
+  await pi.commands.get("agent_vent").handler("unknown", ctx);
+  assert.equal(pi.messages.length, 1);
+  assert.match(notifications[1], /Unknown \/agent_vent action/);
+  assert.equal(_test.isLongCommandOutput("short"), false);
+});
+
+test("agent_vent cancellation fails before expensive store work", async () => {
+  const pi = createMockPi();
+  agentVentExtension(pi.api);
+  const controller = new AbortController();
+  controller.abort();
+  await assert.rejects(
+    () =>
+      pi.tools
+        .get("agent_vent")
+        .execute("cancelled", { action: "summary" }, controller.signal, undefined, {
+          cwd: "/repo",
+          sessionManager: { getSessionFile: () => undefined },
+        }),
+    /cancelled/,
+  );
+});
+
 test("agent_vent records minimized local diagnostics without external authority claims", async () => {
   const pi = createMockPi();
   agentVentExtension(pi.api);
@@ -474,6 +523,146 @@ test("agent_vent records minimized local diagnostics without external authority
   }
 });
 
+test("agent_vent accepts category aliases for tool records and command filters", async () => {
+  const pi = createMockPi();
+  agentVentExtension(pi.api);
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-vent-alias-"));
+  const oldDir = process.env.PI_AGENT_VENT_DIR;
+  const oldLog = console.log;
+  const messages = [];
+  process.env.PI_AGENT_VENT_DIR = dir;
+  console.log = (message) => messages.push(String(message));
+  try {
+    const tool = pi.tools.get("agent_vent");
+    const result = await tool.execute(
+      "tool-call-category-alias",
+      {
+        action: "record",
+        summary: "Workflow friction alias should normalize",
+        category: "workflow_friction",
+        severity: "medium",
+      },
+      undefined,
+      undefined,
+      {
+        cwd: "/repo",
+        sessionManager: { getSessionFile: () => undefined },
+      },
+    );
+
+    assert.equal(result.details.record.category, "workflow");
+    assert.equal(
+      result.details.record.recurrenceKey,
+      "workflow:workflow-friction-alias-should-normalize",
+    );
+
+    const alignmentPreview = await tool.execute(
+      "tool-call-context-alignment-alias",
+      {
+        action: "preview",
+        summary: "Context alignment candidate should remain callable",
+        category: "context_alignment",
+      },
+      undefined,
+      undefined,
+      {
+        cwd: "/repo",
+        sessionManager: { getSessionFile: () => undefined },
+      },
+    );
+    assert.equal(alignmentPreview.details.wouldRecord, true);
+    assert.equal(alignmentPreview.details.recordPreview.category, "other");
+
+    const reviewResult = await tool.execute(
+      "tool-call-category-alias-review",
+      { action: "review", category: "workflow_friction" },
+      undefined,
+      undefined,
+      {
+        cwd: "/repo",
+        sessionManager: { getSessionFile: () => undefined },
+      },
+    );
+    assert.equal(reviewResult.details.reviewQueue.filters.category, "workflow");
+    assert.equal(reviewResult.details.reviewQueue.matchingGroupCount, 1);
+
+    await pi.commands.get("agent_vent").handler("review category=workflow_friction", {
+      hasUI: false,
+    });
+    assert.match(messages[0], /Filters: category=workflow/);
+    assert.doesNotMatch(messages[0], /category=workflow_friction/);
+  } finally {
+    console.log = oldLog;
+    if (oldDir === undefined) delete process.env.PI_AGENT_VENT_DIR;
+    else process.env.PI_AGENT_VENT_DIR = oldDir;
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("agent_vent preview runs anti-junk checks without writing records", async () => {
+  const pi = createMockPi();
+  agentVentExtension(pi.api);
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-vent-preview-"));
+  const oldDir = process.env.PI_AGENT_VENT_DIR;
+  process.env.PI_AGENT_VENT_DIR = dir;
+  try {
+    const tool = pi.tools.get("agent_vent");
+    const preview = await tool.execute(
+      "tool-call-preview",
+      {
+        action: "preview",
+        summary: "Workflow friction alias should normalize before recording",
+        category: "workflow_friction",
+        tool: "self",
+      },
+      undefined,
+      undefined,
+      {
+        cwd: "/repo",
+        sessionManager: { getSessionFile: () => undefined },
+      },
+    );
+
+    assert.equal(preview.details.wouldRecord, true);
+    assert.equal(preview.details.recordPreview.category, "workflow");
+    assert.match(preview.content[0].text, /No local diagnostic record was written/);
+    assert.equal(fs.existsSync(path.join(dir, "vents.jsonl")), false);
+
+    const junkPreview = await tool.execute(
+      "tool-call-preview-junk",
+      { action: "preview", summary: "done" },
+      undefined,
+      undefined,
+      {
+        cwd: "/repo",
+        sessionManager: { getSessionFile: () => undefined },
+      },
+    );
+    assert.equal(junkPreview.details.wouldRecord, false);
+    assert.match(junkPreview.content[0].text, /not recordable/);
+
+    await assert.rejects(
+      () =>
+        tool.execute(
+          "tool-call-record-junk",
+          { action: "record", summary: "done" },
+          undefined,
+          undefined,
+          {
+            cwd: "/repo",
+            sessionManager: { getSessionFile: () => undefined },
+          },
+        ),
+      /anti-junk quality check/,
+    );
+    assert.equal(fs.existsSync(path.join(dir, "vents.jsonl")), false);
+  } finally {
+    if (oldDir === undefined) delete process.env.PI_AGENT_VENT_DIR;
+    else process.env.PI_AGENT_VENT_DIR = oldDir;
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test("agent_vent command rejects unknown review filter keys without creating stores", async () => {
   const pi = createMockPi();
   agentVentExtension(pi.api);

package/tests/release-artifact-check.test.js

@@ -1,3 +1,9 @@
+// ---
+// summary: tests package whitelist parsing and published markdown link validation
+// read_when:
+//   - changing release artifact checks, pack output handling, or files-array policy
+// ---
+
 import assert from "node:assert/strict";
 import fs from "node:fs";
 import os from "node:os";
@@ -77,6 +83,28 @@ test("pack json parser fails closed for malformed, stale, or unsafe pack output"
   );
 });
 
+test("pack json parser accepts canonical arrays and npm 12 package-keyed objects", () => {
+  const entry = { name: "@tryinget/pi-agent-vent", files: [{ path: "package.json" }] };
+  assert.deepEqual(parsePackJson(JSON.stringify([entry])), ["package.json"]);
+  assert.deepEqual(parsePackJson(JSON.stringify({ "@tryinget/pi-agent-vent": entry })), [
+    "package.json",
+  ]);
+  assert.throws(
+    () =>
+      parsePackJson(
+        JSON.stringify({
+          "@tryinget/pi-agent-vent": entry,
+          "@tryinget/other": entry,
+        }),
+      ),
+    /Could not parse npm pack/,
+  );
+  assert.throws(
+    () => parsePackJson(JSON.stringify({ "@tryinget/wrong": entry })),
+    /Could not parse npm pack/,
+  );
+});
+
 test("package files whitelist fails closed for wildcard entries", () => {
   assert.throws(
     () =>
@@ -114,13 +142,19 @@ test("package files whitelist detects missing and extra artifact entries", () =>
 test("release artifact check accepts directory files entries and always-included metadata", () => {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-vent-release-check-ok-"));
   try {
-    fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ files: ["docs"] }));
+    fs.writeFileSync(
+      path.join(dir, "package.json"),
+      JSON.stringify({ name: "@tryinget/pi-agent-vent", version: "0.2.0", files: ["docs"] }),
+    );
     fs.writeFileSync(path.join(dir, "README.md"), "[guide](docs/guide.md)\n");
     fs.writeFileSync(path.join(dir, "LICENSE"), "local test license\n");
     fs.mkdirSync(path.join(dir, "docs"));
     fs.writeFileSync(path.join(dir, "docs", "guide.md"), "# Guide\n");
     const packJsonText = JSON.stringify([
       {
+        id: "@tryinget/pi-agent-vent@0.2.0",
+        name: "@tryinget/pi-agent-vent",
+        version: "0.2.0",
         files: [
           { path: "README.md" },
           { path: "LICENSE" },
@@ -142,18 +176,51 @@ test("release artifact check accepts directory files entries and always-included
   }
 });
 
+test("release artifact check rejects pack identity that differs from the local manifest", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-vent-release-identity-"));
+  try {
+    fs.writeFileSync(
+      path.join(dir, "package.json"),
+      JSON.stringify({ name: "@tryinget/pi-agent-vent", version: "0.2.0", files: ["README.md"] }),
+    );
+    fs.writeFileSync(path.join(dir, "README.md"), "# Agent Vent\n");
+    const packJsonText = JSON.stringify([
+      {
+        id: "@tryinget/not-pi-agent-vent@999.0.0",
+        name: "@tryinget/not-pi-agent-vent",
+        version: "999.0.0",
+        files: [{ path: "README.md" }, { path: "package.json" }],
+      },
+    ]);
+
+    assert.throws(
+      () => runReleaseArtifactCheck({ cwd: dir, packJsonText, log: () => {} }),
+      /npm pack identity mismatch/,
+    );
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test("release artifact check reports packaged markdown failures with actionable wording", () => {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-vent-release-check-"));
   try {
     fs.writeFileSync(
       path.join(dir, "package.json"),
-      JSON.stringify({ files: ["README.md", "docs/guide.md"] }),
+      JSON.stringify({
+        name: "@tryinget/pi-agent-vent",
+        version: "0.2.0",
+        files: ["README.md", "docs/guide.md"],
+      }),
     );
     fs.mkdirSync(path.join(dir, "docs"));
     fs.writeFileSync(path.join(dir, "README.md"), "[missing](docs/missing.md)\n");
     fs.writeFileSync(path.join(dir, "docs", "guide.md"), "# Guide\n");
     const packJsonText = JSON.stringify([
       {
+        id: "@tryinget/pi-agent-vent@0.2.0",
+        name: "@tryinget/pi-agent-vent",
+        version: "0.2.0",
         files: [{ path: "README.md" }, { path: "docs/guide.md" }, { path: "package.json" }],
       },
     ]);

package/tests/release-smoke-check.test.js

@@ -1,3 +1,9 @@
+// ---
+// summary: tests isolated release-smoke contracts for installed agent_vent artifacts
+// read_when:
+//   - changing tarball source validation, package discovery, or path-tool smoke probes
+// ---
+
 import assert from "node:assert/strict";
 import fs from "node:fs";
 import os from "node:os";
@@ -5,6 +11,7 @@ import path from "node:path";
 import test from "node:test";
 import {
   assertAgentVentPathSmokeOutput,
+  assertExactHostContract,
   assertInstalledArtifactPackage,
   assertLocalTarballInstallSource,
   assertPackageSpecInstalled,
@@ -13,6 +20,24 @@ import {
   packageSourcesFromSettings,
 } from "../scripts/release-smoke-check.mjs";
 
+test("release smoke release-age bypass is gated by one exact host contract", () => {
+  const packageJson = {
+    devDependencies: {
+      "@earendil-works/pi-ai": "0.83.0",
+      "@earendil-works/pi-coding-agent": "0.83.0",
+    },
+  };
+  assert.equal(assertExactHostContract({ packageJson, hostVersion: "0.83.0" }), "0.83.0");
+  assert.throws(
+    () => assertExactHostContract({ packageJson, hostVersion: "^0.83.0" }),
+    /requires an exact Pi host version/,
+  );
+  assert.throws(
+    () => assertExactHostContract({ packageJson, hostVersion: "0.83.1" }),
+    /host contract mismatch/,
+  );
+});
+
 test("release smoke settings check accepts only unfiltered string package entries", () => {
   const settings = {
     packages: [

package/tests/vent-store.test.js

@@ -1,3 +1,9 @@
+// ---
+// summary: tests agent vent persistence, redaction, review projections, and retention safety
+// read_when:
+//   - modifying vent-store records, filters, curation, exports, backups, or filesystem guards
+// ---
+
 import assert from "node:assert/strict";
 import { createHash } from "node:crypto";
 import fs from "node:fs";
@@ -111,6 +117,43 @@ test("createVentRecord minimizes, redacts, and derives recurrence key", () => {
   assert.deepEqual(tagOnlySecret.privacy.redactionPatterns, ["assigned_secret"]);
 });
 
+test("category aliases normalize at record and review-filter boundaries", () => {
+  const workflow = createVentRecord({
+    summary: "Workflow alias should not degrade",
+    category: "workflow_friction",
+    recurrenceKey: "workflow alias",
+  });
+  const missing = createVentRecord({
+    summary: "Missing affordance alias should preserve meaning",
+    category: "missing_affordance",
+  });
+  const alignment = createVentRecord({
+    summary: "Context alignment candidate should remain callable",
+    category: "context_alignment",
+  });
+
+  assert.equal(workflow.category, "workflow");
+  assert.equal(workflow.recurrenceKey, "workflow:workflow-alias");
+  assert.equal(missing.category, "missing_capability");
+  assert.match(missing.recurrenceKey, /^missing_capability:/);
+  assert.equal(alignment.category, "other");
+  assert.match(alignment.recurrenceKey, /^other:/);
+
+  const queue = summarizeReviewQueue([workflow, missing, alignment], [], {
+    filters: { category: "workflow_friction" },
+  });
+  assert.equal(queue.filters.category, "workflow");
+  assert.equal(queue.matchingGroupCount, 1);
+  assert.equal(queue.items[0].recurrenceKey, workflow.recurrenceKey);
+
+  const alignmentQueue = summarizeReviewQueue([workflow, missing, alignment], [], {
+    filters: { category: "context_alignment" },
+  });
+  assert.equal(alignmentQueue.filters.category, "other");
+  assert.equal(alignmentQueue.matchingGroupCount, 1);
+  assert.equal(alignmentQueue.items[0].recurrenceKey, alignment.recurrenceKey);
+});
+
 test("explicit recurrence keys are redacted before slugging", () => {
   const record = createVentRecord({
     summary: "Explicit key should not leak",