arisa 5.1.13 → 5.1.49

package/test/tool-registry-run.test.js

@@ -89,6 +89,15 @@ for (const frame of frames) {
   return dir;
 }
 
+async function createHangingTool(name = "hanging-tool") {
+  const dir = await createFakeTool(name);
+  await writeFile(path.join(dir, "index.js"), `
+process.on("SIGTERM", () => {});
+setInterval(() => {}, 1_000);
+`, "utf8");
+  return dir;
+}
+
 test("loads and lists installed tools from the user tools directory", async () => {
   await resetHome();
   await createFakeTool("fake-tool", {
@@ -104,6 +113,7 @@ test("loads and lists installed tools from the user tools directory", async () =
     version: null,
     packageDigest: null,
     requirements: [],
+    toolDependencies: {},
     description: "Fake test tool",
     input: ["text/plain"],
     output: ["text/plain"],
@@ -116,6 +126,28 @@ test("loads and lists installed tools from the user tools directory", async () =
   }]);
 });
 
+test("keeps the previous complete snapshot visible while a reload is in progress", async () => {
+  const registry = new ToolRegistry();
+  const previous = { name: "stable-tool" };
+  const replacement = { name: "replacement-tool" };
+  registry.tools = new Map([[previous.name, previous]]);
+
+  let releaseSnapshot;
+  registry.buildSnapshot = () => new Promise((resolve) => {
+    releaseSnapshot = () => resolve(new Map([[replacement.name, replacement]]));
+  });
+
+  const loading = registry.load();
+  for (let attempt = 0; attempt < 1_000; attempt += 1) {
+    assert.equal(registry.get(previous.name), previous);
+  }
+  releaseSnapshot();
+  await loading;
+
+  assert.equal(registry.get(previous.name), null);
+  assert.equal(registry.get(replacement.name), replacement);
+});
+
 test("lists optional semantic metadata with stable defaults", async () => {
   await resetHome();
   await createFakeTool("fake-tool");
@@ -144,6 +176,23 @@ test("shows semantic metadata in tool help", async () => {
   assert.match(help, /Assigned skills:/);
 });
 
+test("reports dependency status in help and blocks a tool with a missing dependency", async () => {
+  await resetHome();
+  await createFakeTool("dependent-tool", {
+    version: "1.0.0",
+    toolDependencies: { "base-tool": "^1.0.0" }
+  });
+
+  const registry = new ToolRegistry();
+  await registry.load();
+
+  assert.match(await registry.help("dependent-tool"), /base-tool@\^1\.0\.0: missing/);
+  await assert.rejects(
+    () => registry.run({ name: "dependent-tool", request: { args: {} } }),
+    /Tool dependency missing/
+  );
+});
+
 test("runs a registered tool process with an enriched request and cleans up request files", async () => {
   await resetHome();
   await createFakeTool("fake-tool");
@@ -178,7 +227,7 @@ test("runs a registered tool process with an enriched request and cleans up requ
   });
   assert.equal(result.output.env.ARISA_PACKAGE_DIR, arisaPackageDir);
   assert.equal(result.output.env.ARISA_IPC_SOCKET, arisaIpcSocketFile);
-  assert.deepEqual(await registry.usage("chat-1"), [{ name: "fake-tool", count: 1 }]);
+  assert.deepEqual(await registry.usage("chat-1"), [{ name: "fake-tool", count: 1, official: false }]);
 
   const requestFile = result.output.requestFile;
   await assert.rejects(() => access(requestFile), { code: "ENOENT" });
@@ -216,6 +265,37 @@ test("rejects unknown tools", async () => {
   );
 });
 
+test("terminates timed-out tool runs and requires a status check before retry", async () => {
+  await resetHome();
+  await createHangingTool();
+  const registry = new ToolRegistry({ runTimeoutMs: 20, killGraceMs: 20 });
+  await registry.load();
+
+  const result = await registry.run({
+    name: "hanging-tool",
+    chatId: "chat-1",
+    request: { args: {} }
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.status, "outcome_uncertain");
+  assert.equal(result.resolution.type, "status_check_required");
+  assert.equal(result.resolution.retry, false);
+  assert.match(result.error, /timed out after 20ms/);
+});
+
+test("terminates timed-out tool help processes", async () => {
+  await resetHome();
+  await createHangingTool();
+  const registry = new ToolRegistry({ helpTimeoutMs: 20, killGraceMs: 20 });
+  await registry.load();
+
+  await assert.rejects(
+    () => registry.help("hanging-tool"),
+    /Tool help for hanging-tool timed out after 20ms/
+  );
+});
+
 test("parses fragmented NDJSON incrementally and keeps stderr diagnostic-only", async () => {
   await resetHome();
   await createStreamingTool();

package/test/tool-usage.test.js

@@ -3,6 +3,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
+import { ToolRegistry } from "../src/core/tools/tool-registry.js";
 import { ToolUsageStore } from "../src/core/tools/tool-usage-store.js";
 import { formatToolUsageReport } from "../src/runtime/tool-usage-report.js";
 
@@ -26,16 +27,37 @@ test("counts concurrent tool uses per chat", async () => {
   }
 });
 
+test("reports recorded usage for local tools not present in the startup registry", async () => {
+  const registry = new ToolRegistry({
+    usageStore: {
+      counts: async () => ({ "creator-scout": 4 })
+    },
+    resolveOfficialToolNames: async () => new Set(["gmail-workspace"])
+  });
+  registry.tools.set("gmail-workspace", {
+    name: "gmail-workspace",
+    input: ["application/json"],
+    output: ["application/json"]
+  });
+
+  assert.deepEqual(await registry.usage("chat-1"), [
+    { name: "creator-scout", count: 4, official: false },
+    { name: "gmail-workspace", count: 0, official: true }
+  ]);
+});
+
 test("formats narrow tool usage counts with bullets and right-aligned numbers", () => {
   const report = formatToolUsageReport([
-    { name: "gmail-workspace", count: 3 },
-    { name: "campaign-draft-runner", count: 12 }
+    { name: "gmail-workspace", count: 3, official: true },
+    { name: "campaign-draft-runner", count: 12, official: false }
   ]);
+  assert.match(report, /Official\n- gmail-workspace/);
+  assert.match(report, /Local\n- campaign-draft-runner/);
   assert.match(report, /- campaign-draft-runner  12/);
   assert.match(report, /- gmail-workspace\s+3/);
   const rows = report.split("\n").filter((line) => line.startsWith("- "));
-  assert.match(rows[0], /campaign-draft-runner/);
-  assert.match(rows[1], /gmail-workspace/);
+  assert.match(rows[0], /gmail-workspace/);
+  assert.match(rows[1], /campaign-draft-runner/);
   assert.deepEqual(rows.map((line) => line.match(/\d+$/).index + line.match(/\d+$/)[0].length), [27, 27]);
   assert.deepEqual(rows.map((line) => line.length), [27, 27]);
   assert.ok(report.split("\n").every((line) => [...line].length <= 35));

package/test/topic-initialization.test.js

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { buildTopicInitializationHandoff, isProcessableTelegramMessage, startTelegramTyping } from "../src/transport/telegram/bot.js";
+import { SessionSeedStore } from "../src/core/conversation/session-seed-store.js";
+
+test("Telegram typing action stays inside the message topic", async () => {
+  const calls = [];
+  const stop = await startTelegramTyping({
+    chat: { id: "chat-1" },
+    message: { message_thread_id: 42 },
+    api: {
+      sendChatAction: async (chatId, action, options) => {
+        calls.push({ chatId, action, options });
+      }
+    }
+  });
+  stop();
+
+  assert.deepEqual(calls, [
+    { chatId: "chat-1", action: "typing", options: { message_thread_id: 42 } }
+  ]);
+});
+
+test("Telegram service messages do not become empty agent prompts", () => {
+  assert.equal(isProcessableTelegramMessage({ forum_topic_created: { name: "Stories" } }), false);
+  assert.equal(isProcessableTelegramMessage({ forum_topic_edited: { name: "Stories" } }), false);
+  assert.equal(isProcessableTelegramMessage({ text: "hello" }), true);
+  assert.equal(isProcessableTelegramMessage({ voice: { file_id: "voice" } }), true);
+});
+
+test("topic initialization context is explicit and bounded to the topic", () => {
+  const handoff = buildTopicInitializationHandoff({ name: "Stories", context: "Draft first-person development stories for arisa.sh." });
+  assert.match(handoff, /Telegram topic: Stories/);
+  assert.match(handoff, /isolated conversation session/);
+  assert.match(handoff, /Draft first-person development stories/);
+});
+
+test("a persisted session seed is consumed exactly once and can be replaced", async () => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "arisa-topic-seed-"));
+  const seedFile = (chatId) => path.join(directory, `${chatId}.jsonl`);
+  const legacyFile = (chatId) => path.join(directory, `${chatId}.legacy.jsonl`);
+  const store = new SessionSeedStore({ seedFile, legacyFile });
+  try {
+    await store.set("topic", "Stories context");
+    assert.equal(await store.consume("topic"), "Stories context");
+    assert.equal(await store.consume("topic"), "");
+
+    await store.set("topic", "Replacement context");
+    assert.equal(await store.consume("topic"), "Replacement context");
+
+    await writeFile(legacyFile("pending-legacy"), `${JSON.stringify({ kind: "seed", history: "Pending legacy context" })}\n`, "utf8");
+    assert.equal(await store.consume("pending-legacy"), "Pending legacy context");
+
+    await writeFile(legacyFile("legacy"), [
+      JSON.stringify({ kind: "seed", history: "Old portable context" }),
+      JSON.stringify({ kind: "turn", prompt: "stale", response: "stale" }),
+      ""
+    ].join("\n"), "utf8");
+    assert.equal(await store.consume("legacy"), "");
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});

package/src/core/conversation/conversation-history-store.js

@@ -1,142 +0,0 @@
-import crypto from "node:crypto";
-import { mkdir, open, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { getChatConversationHistoryFile } from "../../runtime/paths.js";
-
-const utf8Bom = "\uFEFF";
-
-function normalizeText(value) {
-  return String(value || "").trim();
-}
-
-function parseHistory(contents) {
-  return String(contents || "")
-    .replace(/^\uFEFF/, "")
-    .split(/\r?\n/)
-    .filter(Boolean)
-    .map((line) => JSON.parse(line));
-}
-
-function serializeRecord(record) {
-  return `${JSON.stringify(record)}\n`;
-}
-
-export function formatPortableConversation(records) {
-  if (!records.length) return "";
-  const sections = [
-    "Portable Arisa conversation history.",
-    "This portable history belongs to the same Telegram chat and is independent of the active agent harness.",
-    "Use it as prior conversation context. Do not repeat it unless the user asks."
-  ];
-
-  for (const record of records) {
-    if (record.kind === "seed") {
-      sections.push(`Imported earlier conversation:\n${record.history}`);
-      continue;
-    }
-    const parts = [];
-    if (record.prompt) parts.push(`User or system request:\n${record.prompt}`);
-    if (record.response) parts.push(`Assistant response:\n${record.response}`);
-    if (parts.length) sections.push(parts.join("\n\n"));
-  }
-  return sections.join("\n\n---\n\n");
-}
-
-export class ConversationHistoryStore {
-  constructor({ historyFile = getChatConversationHistoryFile } = {}) {
-    this.locks = new Map();
-    this.historyFile = historyFile;
-  }
-
-  async withChatLock(chatId, work) {
-    const key = String(chatId);
-    const previous = this.locks.get(key) || Promise.resolve();
-    const current = previous.catch(() => {}).then(work);
-    this.locks.set(key, current);
-    try {
-      return await current;
-    } finally {
-      if (this.locks.get(key) === current) this.locks.delete(key);
-    }
-  }
-
-  async read(chatId) {
-    try {
-      return parseHistory(await readFile(this.historyFile(chatId), "utf8"));
-    } catch (error) {
-      if (error?.code === "ENOENT") return [];
-      throw error;
-    }
-  }
-
-  async hasEntries(chatId) {
-    return (await this.read(chatId)).length > 0;
-  }
-
-  async appendRecord(chatId, record) {
-    const file = this.historyFile(chatId);
-    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
-    const handle = await open(file, "a+", 0o600);
-    try {
-      const stats = await handle.stat();
-      if (stats.size === 0) await handle.write(utf8Bom);
-      await handle.write(serializeRecord(record));
-    } finally {
-      await handle.close();
-    }
-  }
-
-  async ensureSeed(chatId, { runtime, history }) {
-    const normalizedHistory = normalizeText(history);
-    if (!normalizedHistory) return false;
-    return this.withChatLock(chatId, async () => {
-      if ((await this.read(chatId)).length) return false;
-      await this.appendRecord(chatId, {
-        id: crypto.randomUUID(),
-        kind: "seed",
-        runtime,
-        history: normalizedHistory,
-        createdAt: new Date().toISOString()
-      });
-      return true;
-    });
-  }
-
-  async appendTurn(chatId, { runtime, prompt, response }) {
-    const normalizedPrompt = normalizeText(prompt);
-    const normalizedResponse = normalizeText(response);
-    if (!normalizedPrompt && !normalizedResponse) return null;
-    const record = {
-      id: crypto.randomUUID(),
-      kind: "turn",
-      runtime,
-      prompt: normalizedPrompt,
-      response: normalizedResponse,
-      createdAt: new Date().toISOString()
-    };
-    await this.withChatLock(chatId, () => this.appendRecord(chatId, record));
-    return record;
-  }
-
-  async reset(chatId, { runtime, history = "" } = {}) {
-    return this.withChatLock(chatId, async () => {
-      const file = this.historyFile(chatId);
-      await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
-      const normalizedHistory = normalizeText(history);
-      const seed = normalizedHistory
-        ? serializeRecord({
-            id: crypto.randomUUID(),
-            kind: "seed",
-            runtime,
-            history: normalizedHistory,
-            createdAt: new Date().toISOString()
-          })
-        : "";
-      await writeFile(file, `${utf8Bom}${seed}`, { encoding: "utf8", mode: 0o600 });
-    });
-  }
-
-  async buildHandoff(chatId) {
-    return formatPortableConversation(await this.read(chatId));
-  }
-}