arisa 3.0.6 → 3.0.8

package/AGENTS.md

@@ -1,11 +1,11 @@
 # Arisa AGENTS
 
 ## Architecture
-- `src/transport/telegram/*`: Telegram inbound and outbound transport.
-- `src/core/agent/*`: Pi Agent sessions, one per authorized chat.
-- `src/core/artifacts/*`: every incoming or generated message/file becomes an artifact.
-- `src/core/tools/*`: CLI tool registry, help lookup, config writes, execution.
-- `tools/*`: isolated tools. Each tool has `package.json`, `config.js`, `tool.manifest.json`, and `index.js`.
+- Telegram transport handles inbound and outbound messaging.
+- Pi Agent keeps one session per authorized chat.
+- Every incoming or generated message or file becomes an artifact.
+- A tool registry handles tool discovery, help lookup, config writes, and execution.
+- Tools are isolated and each one has its own manifest, entrypoint, and config defaults.
 
 ## Main rule: everything is piped through artifacts
 A pipe transforms one input artifact into one output artifact.
@@ -70,27 +70,14 @@ Example manual pipe:
 ## Missing config flow
 If `run_tool` returns `missingConfig`, the agent should:
 1. ask the user naturally in Telegram for the missing value
-2. write the value into `~/.arisa/tools/<tool>/config.js` with `set_tool_config`
+2. write the value with `set_tool_config`
 3. retry the tool
 
 Do not assume a rigid question/answer protocol. Continue the conversation naturally and infer the config value from the user reply when possible.
 
-## Long-running work
-If a task is likely to take noticeable time — for example creating a new tool, editing multiple files, or doing multi-step work — the agent should first acknowledge the request briefly and naturally, then continue the work.
-
-The acknowledgment should:
-- be short and clear
-- tell the user the work is starting
-- mention when the task may take a while
-
-Examples:
-- "Understood. I'll build that tool now. This may take a couple of minutes."
-- "Got it. I'll inspect the project and make the change now."
-
 ## Tool creation
-Do not assume specific future tools such as YouTube support exist.
 If the user asks for a capability that is not currently available, first check whether an existing registered tool can satisfy the task.
-If no existing tool can do it, the default attitude should be to propose creating a new CLI tool under `tools/<tool-name>` following the project conventions.
+If no existing tool can do it, the default attitude should be to propose creating a new CLI tool following the project conventions.
 All newly created tools must document their help text, usage instructions, manifests, and user-facing operational strings in English.
 Do not stop at "I cannot do that" when the task is realistically implementable through a new tool.
 Prefer responses like:
@@ -100,15 +87,11 @@ Prefer responses like:
 
 For example, if the user asks for live weather and no weather tool exists, the correct attitude is to propose building a weather tool for the bot rather than only saying real-time access is unavailable.
 
-When creating or editing tools, follow the shared path helpers in `src/runtime/paths.js` and `src/core/tools/tool-config.js`:
-- config in `~/.arisa/tools/<tool>/config.js`
-- temp/runtime files in `~/.arisa/tmp/tools/<tool>/`
-- durable generated files should become artifacts in `~/.arisa/artifacts/`
-
+When creating or editing tools, use the shared path helpers and the runtime paths provided in the prompt instead of assuming fixed locations.
 Consult the local skill for that workflow when building new tools.
 
 ## Safety
-- Do not install or run arbitrary tools outside registered `tools/*` manifests in V1.
+- Do not install or run arbitrary tools outside registered tool manifests in V1.
 - Prefer tool manifests and CLI help over assumptions.
-- Keep tool configs inside `~/.arisa/tools/<tool>/config.js`.
+- Keep tool config and runtime data inside the user runtime area.
 - Be proactive about extending capabilities, but do it through the project's tool architecture, not through ad hoc one-off behavior.

package/README.md

@@ -46,7 +46,9 @@ This distinction is important. Some transformations belong to the transport/inpu
 - media is stored as artifacts
 
 ### Tool model
-Each tool lives in its own folder under `tools/<tool-name>` and contains:
+Bundled tools live under `<arisa-install-dir>/tools/<tool-name>` and user-created tools live under `~/.arisa/tools/<tool-name>`.
+
+Each tool folder contains:
 
 - `package.json`
 - `config.js`
@@ -57,7 +59,8 @@ Each tool is isolated from the root project and from other tools.
 That isolation is part of the architecture:
 
 - each tool has its own folder
-- each tool has a local `config.js` only for defaults/template values
+- bundled tools have a local `config.js` for defaults/template values
+- user-created tools can live entirely inside `~/.arisa/tools/<tool>/`
 - each tool can have its own dependencies
 - one tool can be changed or replaced without tightly coupling the rest of the system
 
@@ -74,8 +77,8 @@ node index.js run --request-file <json>
 - artifact index is stored in `~/.arisa/state/artifacts.json`
 - incoming Telegram attachments are stored directly in `~/.arisa/artifacts/`
 - tool-specific secrets/config live in `~/.arisa/tools/<tool>/config.js`
-- bundled tools and generated tools should both use the same source layout under `tools/<tool>/`
-- tool runtime temp files and generated outputs live in `~/.arisa/tmp/tools/<tool>/`
+- user-created tools also live under `~/.arisa/tools/<tool>/`
+- tool runtime temp files and generated outputs live under `~/.arisa/tools/<tool>/` (for example `tmp/` and `out/`)
 - durable files should end up in `~/.arisa/artifacts/`
 - Pi authentication can use either:
   - an API key entered during bootstrap

package/package.json

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

package/src/core/agent/agent-manager.js

@@ -4,6 +4,7 @@ import { createAgentSession, SessionManager, defineTool } from "@mariozechner/pi
 import { Type } from "@sinclair/typebox";
 import { createPiRuntime, hasProviderAuth } from "./pi-runtime.js";
 import { loadProjectInstructions } from "./project-instructions.js";
+import { buildAgentRuntimeContext } from "./runtime-context.js";
 import { getChatDir, piAgentDir as agentDir } from "../../runtime/paths.js";
 
 export class AgentManager {
@@ -76,8 +77,10 @@ export class AgentManager {
     });
 
     const instructions = await loadProjectInstructions();
+    const runtimeContext = buildAgentRuntimeContext(chatId);
     this.logger?.log("agent", `injecting project instructions for chat ${chatId}`);
-    await session.prompt(`${instructions}\n\nAcknowledge with exactly: OK`);
+    this.logger?.log("agent", `runtime context for chat ${chatId}:\n${runtimeContext}`);
+    await session.prompt(`${instructions}\n\n${runtimeContext}\n\nAcknowledge with exactly: OK`);
 
     const ctx = { session };
     this.sessions.set(chatId, ctx);

package/src/core/agent/runtime-context.js

@@ -0,0 +1,17 @@
+import { fileURLToPath } from "node:url";
+import { arisaHomeDir, artifactsDir, getChatDir, stateDir, toolsDir } from "../../runtime/paths.js";
+
+export const arisaInstallDir = fileURLToPath(new URL("../../..", import.meta.url));
+export const bundledToolsDir = fileURLToPath(new URL("../../../tools", import.meta.url));
+
+export function buildAgentRuntimeContext(chatId) {
+  return [
+    `arisaHomeDir: ${arisaHomeDir}`,
+    `arisaInstallDir: ${arisaInstallDir}`,
+    `bundledToolsDir: ${bundledToolsDir}`,
+    `userToolsDir: ${toolsDir}`,
+    `artifactsDir: ${artifactsDir}`,
+    `stateDir: ${stateDir}`,
+    `chatWorkspaceDir: ${getChatDir(chatId)}`
+  ].join("\n");
+}

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

@@ -1,10 +1,15 @@
 import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";
-import { getToolConfigPath, getToolTmpDir } from "../../runtime/paths.js";
+import { fileURLToPath } from "node:url";
+import { getToolConfigPath, getToolTmpDir, toolsDir as userToolsRoot } from "../../runtime/paths.js";
 import { loadToolConfig, parseConfigModule, writeToolConfig } from "./tool-config.js";
 
-const toolsRoot = path.resolve("tools");
+const bundledToolsRoot = fileURLToPath(new URL("../../../tools", import.meta.url));
+const toolRoots = [
+  { root: userToolsRoot, kind: "user" },
+  { root: bundledToolsRoot, kind: "bundled" }
+];
 
 function runProcess(command, args, options = {}) {
   return new Promise((resolve) => {
@@ -26,35 +31,39 @@ export class ToolRegistry {
   async load() {
     this.tools.clear();
 
-    let entries = [];
-    try {
-      entries = await readdir(toolsRoot, { withFileTypes: true });
-    } catch {
-      this.logger?.log("tools", `tools directory not found: ${toolsRoot}`);
-      return;
-    }
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const toolDir = path.join(toolsRoot, entry.name);
-      const manifestPath = path.join(toolDir, "tool.manifest.json");
-      const configPath = path.join(toolDir, "config.js");
+    for (const { root, kind } of toolRoots) {
+      let entries = [];
       try {
-        const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
-        const configSource = await readFile(configPath, "utf8");
-        const defaults = parseConfigModule(configSource);
-        const config = await loadToolConfig(manifest.name, defaults);
-        this.tools.set(manifest.name, {
-          ...manifest,
-          dir: toolDir,
-          entry: path.join(toolDir, manifest.entry || "index.js"),
-          localConfigPath: configPath,
-          configPath: getToolConfigPath(manifest.name),
-          defaults,
-          config
-        });
+        entries = await readdir(root, { withFileTypes: true });
       } catch {
-        // ignore invalid tool dirs in v1
+        this.logger?.log("tools", `${kind} tools directory not found: ${root}`);
+        continue;
+      }
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const toolDir = path.join(root, entry.name);
+        const manifestPath = path.join(toolDir, "tool.manifest.json");
+        const configPath = path.join(toolDir, "config.js");
+        try {
+          const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+          if (this.tools.has(manifest.name)) continue;
+          const configSource = await readFile(configPath, "utf8");
+          const defaults = parseConfigModule(configSource);
+          const config = await loadToolConfig(manifest.name, defaults);
+          this.tools.set(manifest.name, {
+            ...manifest,
+            dir: toolDir,
+            entry: path.join(toolDir, manifest.entry || "index.js"),
+            localConfigPath: configPath,
+            configPath: getToolConfigPath(manifest.name),
+            defaults,
+            config,
+            sourceKind: kind
+          });
+        } catch {
+          // ignore invalid tool dirs in v1
+        }
       }
     }
 

package/src/runtime/paths.js

@@ -10,7 +10,7 @@ export const serviceLogFile = path.join(stateDir, "arisa.log");
 export const artifactsDir = path.join(arisaHomeDir, "artifacts");
 export const artifactsIndexFile = path.join(stateDir, "artifacts.json");
 export const piAgentDir = path.join(stateDir, "pi-agent");
-export const chatsDir = path.join(stateDir, "chats");
+export const chatsDir = path.join(arisaHomeDir, "chats");
 export const toolsDir = path.join(arisaHomeDir, "tools");
 export const tmpDir = path.join(arisaHomeDir, "tmp");
 
@@ -27,7 +27,7 @@ export function getToolConfigPath(toolName) {
 }
 
 export function getToolRuntimeDir(toolName) {
-  return path.join(tmpDir, "tools", toolName);
+  return getToolDir(toolName);
 }
 
 export function getToolOutDir(toolName) {