arisa 4.2.0 → 4.2.2

package/AGENTS.md

@@ -43,6 +43,8 @@ Each tool declares in `tool.manifest.json`:
 - `input`: supported input types
 - `output`: produced output types
 - `configSchema`: required config fields
+- `category`: optional broad capability bucket for discovery
+- `keywords`: optional intent tags for capability discovery
 - `skillHints`: optional skills to apply when using or editing the tool
 
 ## Tool-to-Arisa IPC
@@ -166,6 +168,8 @@ Do not assume a rigid question/answer protocol. Continue the conversation natura
 ## Capability resolution
 Reason in terms of capabilities, not tool names. Do not stop at "I cannot do that" when the task is realistically implementable through the tool architecture.
 
+Before asking the user for recurrent context, inspect available tools by `category` and `keywords`, especially `memory`, `context`, `contacts`, and `essential`.
+
 When the user asks for something new:
 1. check whether an existing registered tool, or an indirect use of one, can satisfy the task
 2. check the official catalog at `https://github.com/clasen/Arisa/tree/main/tools` before building anything

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "4.2.0",
+  "version": "4.2.2",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

package/src/core/tools/tool-registry.js

@@ -21,6 +21,28 @@ function runProcess(command, args, options = {}) {
   });
 }
 
+function normalizeCategory(category) {
+  if (typeof category !== "string") return null;
+  const trimmed = category.trim();
+  return trimmed || null;
+}
+
+function normalizeKeywords(keywords) {
+  if (!Array.isArray(keywords)) return [];
+  return [...new Set(keywords
+    .filter((keyword) => typeof keyword === "string")
+    .map((keyword) => keyword.trim())
+    .filter(Boolean))];
+}
+
+function formatSemanticMetadata(tool) {
+  return [
+    "Semantic metadata:",
+    `- category: ${tool.category || "none"}`,
+    `- keywords: ${tool.keywords?.length ? tool.keywords.join(", ") : "none"}`
+  ].join("\n");
+}
+
 export class ToolRegistry {
   constructor({ logger } = {}) {
     this.logger = logger;
@@ -52,6 +74,8 @@ export class ToolRegistry {
         const skillHints = this.skillRegistry.normalizeHints(manifest);
         this.tools.set(manifest.name, {
           ...manifest,
+          category: normalizeCategory(manifest.category),
+          keywords: normalizeKeywords(manifest.keywords),
           skillHints,
           dir: toolDir,
           entry: path.join(toolDir, manifest.entry || "index.js"),
@@ -75,6 +99,8 @@ export class ToolRegistry {
       input: tool.input,
       output: tool.output,
       configSchema: tool.configSchema || {},
+      category: tool.category,
+      keywords: tool.keywords || [],
       skillHints: tool.skillHints || []
     }));
   }
@@ -89,13 +115,19 @@ export class ToolRegistry {
     const result = await runProcess("node", [tool.entry, "--help"], { cwd: tool.dir, env: toolEnv() });
     const help = result.stdout || result.stderr;
     const skills = await this.resolveSkills(name);
-    if (!skills.length) return help;
-    const skillHelp = skills.map((item) => [
-      `- ${item.name}${item.when ? ` (${item.when})` : ""}`,
-      item.description ? `  ${item.description}` : null,
-      item.found ? `  path: ${item.path}` : "  warning: skill not found"
-    ].filter(Boolean).join("\n")).join("\n");
-    return `${help}\n\nAssigned skills:\n${skillHelp}\n`;
+    const sections = [
+      help.trimEnd(),
+      formatSemanticMetadata(tool)
+    ];
+    if (skills.length) {
+      const skillHelp = skills.map((item) => [
+        `- ${item.name}${item.when ? ` (${item.when})` : ""}`,
+        item.description ? `  ${item.description}` : null,
+        item.found ? `  path: ${item.path}` : "  warning: skill not found"
+      ].filter(Boolean).join("\n")).join("\n");
+      sections.push(`Assigned skills:\n${skillHelp}`);
+    }
+    return `${sections.filter(Boolean).join("\n\n")}\n`;
   }
 
   async resolveSkills(name) {

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

@@ -20,10 +20,10 @@ async function resetHome() {
   await rm(arisaHomeDir, { recursive: true, force: true });
 }
 
-async function createFakeTool(name = "fake-tool") {
+async function createFakeTool(name = "fake-tool", manifestOverrides = {}) {
   const dir = path.join(toolsDir, name);
   await mkdir(dir, { recursive: true });
-  await writeFile(path.join(dir, "tool.manifest.json"), `${JSON.stringify({
+  const manifest = {
     name,
     description: "Fake test tool",
     entry: "index.js",
@@ -33,6 +33,10 @@ async function createFakeTool(name = "fake-tool") {
       apiKey: { type: "string", required: false }
     },
     skillHints: [{ name: "missing-skill", when: "testing" }]
+  };
+  await writeFile(path.join(dir, "tool.manifest.json"), `${JSON.stringify({
+    ...manifest,
+    ...manifestOverrides
   }, null, 2)}\n`, "utf8");
   await writeFile(path.join(dir, "config.js"), "export default {\n  apiKey: \"default-key\"\n};\n", "utf8");
   await writeFile(path.join(dir, "index.js"), `import { readFile } from "node:fs/promises";
@@ -67,7 +71,10 @@ process.stdout.write(JSON.stringify({
 
 test("loads and lists installed tools from the user tools directory", async () => {
   await resetHome();
-  await createFakeTool("fake-tool");
+  await createFakeTool("fake-tool", {
+    category: "memory",
+    keywords: ["memory", "essential"]
+  });
 
   const registry = new ToolRegistry();
   await registry.load();
@@ -80,10 +87,40 @@ test("loads and lists installed tools from the user tools directory", async () =
     configSchema: {
       apiKey: { type: "string", required: false }
     },
+    category: "memory",
+    keywords: ["memory", "essential"],
     skillHints: [{ name: "missing-skill", when: "testing" }]
   }]);
 });
 
+test("lists optional semantic metadata with stable defaults", async () => {
+  await resetHome();
+  await createFakeTool("fake-tool");
+
+  const registry = new ToolRegistry();
+  await registry.load();
+
+  assert.equal(registry.list()[0].category, null);
+  assert.deepEqual(registry.list()[0].keywords, []);
+});
+
+test("shows semantic metadata in tool help", async () => {
+  await resetHome();
+  await createFakeTool("fake-tool", {
+    category: "memory",
+    keywords: ["memory", "essential"]
+  });
+
+  const registry = new ToolRegistry();
+  await registry.load();
+
+  const help = await registry.help("fake-tool");
+
+  assert.match(help, /Fake test tool help/);
+  assert.match(help, /Semantic metadata:\n- category: memory\n- keywords: memory, essential/);
+  assert.match(help, /Assigned skills:/);
+});
+
 test("runs a registered tool process with an enriched request and cleans up request files", async () => {
   await resetHome();
   await createFakeTool("fake-tool");