arisa 3.0.8 → 3.0.10

package/AGENTS.md

@@ -76,19 +76,30 @@ If `run_tool` returns `missingConfig`, the agent should:
 Do not assume a rigid question/answer protocol. Continue the conversation naturally and infer the config value from the user reply when possible.
 
 ## Tool creation
-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 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:
-- identify that no current tool satisfies the request
-- state that the missing capability can be added
-- propose or start creating the tool needed to fulfill the request
+Reason in terms of capabilities, not tool names.
 
-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 the user asks for something new:
+1. check whether an existing registered tool can already satisfy the task
+2. also check whether the task can be satisfied indirectly through an existing capability
+3. only propose creating a new tool when the needed capability is truly missing
 
-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.
+Do not stop at "I cannot do that" when the task is realistically implementable through the tool architecture.
+The default attitude is:
+- identify that no current tool satisfies the request
+- state that the missing capability can be added
+- propose or start creating the needed tool
+
+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
+- keep all help text, usage instructions, manifests, and user-facing operational strings in English
+- follow the One Thing Rule: each function or method should do one thing well; if it mixes low-level operations with high-level policy, split it into smaller focused units
+
+## Dependency installation
+Arisa installs tool dependencies itself.
+- Prefer `pnpm install`.
+- Fall back to `npm install`.
+- Do not ask the user to do it manually.
 
 ## Safety
 - Do not install or run arbitrary tools outside registered tool manifests in V1.

package/README.md

@@ -4,7 +4,7 @@ Arisa is a personal Telegram assistant powered by Pi Agent.
 
 ## Origin
 
-The initial inspiration was [OpenClaw](https://github.com/openclaw/openclaw). OpenClaw has interesting ideas but carries too much weight: when it generates tools they end up disorganized, and the overall framework feels overloaded for personal use.
+The initial inspiration was [OpenClaw](https://github.com/openclaw/openclaw). OpenClaw has interesting ideas but carries a lot of weight (about **185 MB**) compared to Arisa (**76.7 kB**): when it generates tools they end up disorganized, and the overall framework feels overloaded.
 
 The real heart of OpenClaw is Pi Agent: a [minimal terminal coding harness](https://www.youtube.com/watch?v=Dli5slNaJu0) that lets an AI agent reason and act with very little infrastructure. That part is genuinely good.
 
@@ -99,13 +99,26 @@ arisa
 Command modes:
 
 ```bash
-arisa            # foreground, blocking
-arisa start      # start in background
-arisa stop       # stop background service
-arisa status     # show background service status
-arisa flush      # remove ~/.arisa
+arisa                    # foreground, blocking
+arisa start              # start in background
+arisa stop               # stop background service
+arisa status             # show background service status
+arisa flush              # remove ~/.arisa
+arisa install <source>   # install a Pi package into Arisa's runtime
+arisa remove <source>    # remove a Pi package from Arisa's runtime
 ```
 
+## Experimental features
+
+### Pi Agent packages
+
+Arisa can install **Pi Agent packages** from the public registry into your user runtime (`~/.arisa/`), using the same package manager as Pi Agent. Browse and discover packages at [pi.dev/packages](https://pi.dev/packages).
+
+- `arisa install <source>` installs a package (by registry name or other source supported by Pi).
+- `arisa remove <source>` removes a previously installed package.
+
+Treat this as **experimental**: the registry, package formats, and install behavior follow Pi Agent and may change. Not every listed package is tailored to Arisa’s Telegram transport and artifact-based tools; prefer packages you understand and verify after install.
+
 ## Bootstrap flow
 
 On first run, Arisa will:

package/package.json

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

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

@@ -1,11 +1,11 @@
 import path from "node:path";
-import { mkdir, unlink } from "node:fs/promises";
+import { unlink } from "node:fs/promises";
 import { createAgentSession, SessionManager, defineTool } from "@mariozechner/pi-coding-agent";
 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";
+import { arisaInstallDir, buildAgentRuntimeContext } from "./runtime-context.js";
+import { arisaHomeDir } from "../../runtime/paths.js";
 
 export class AgentManager {
   constructor({ config, artifactStore, toolRegistry, logger }) {
@@ -50,7 +50,6 @@ export class AgentManager {
       return this.sessions.get(chatId);
     }
 
-    await mkdir(agentDir, { recursive: true });
     const { authStorage, modelRegistry } = createPiRuntime({
       provider: this.config.pi.provider,
       apiKey: this.config.pi.apiKey
@@ -61,23 +60,20 @@ export class AgentManager {
       throw new Error(`No auth found for ${this.config.pi.provider}. Re-run bootstrap and complete login for this provider before Telegram starts.`);
     }
 
-    const cwd = getChatDir(chatId);
-    await mkdir(cwd, { recursive: true });
-
     this.logger?.log("agent", `creating session for chat ${chatId}`);
     const customTools = this.createTools(telegram);
     const { session } = await createAgentSession({
-      cwd,
-      agentDir,
+      cwd: arisaInstallDir,
+      agentDir: arisaHomeDir,
       authStorage,
       modelRegistry,
       model,
       customTools,
-      sessionManager: SessionManager.continueRecent(cwd)
+      sessionManager: SessionManager.inMemory()
     });
 
     const instructions = await loadProjectInstructions();
-    const runtimeContext = buildAgentRuntimeContext(chatId);
+    const runtimeContext = buildAgentRuntimeContext();
     this.logger?.log("agent", `injecting project instructions for chat ${chatId}`);
     this.logger?.log("agent", `runtime context for chat ${chatId}:\n${runtimeContext}`);
     await session.prompt(`${instructions}\n\n${runtimeContext}\n\nAcknowledge with exactly: OK`);

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

@@ -1,17 +1,16 @@
 import { fileURLToPath } from "node:url";
-import { arisaHomeDir, artifactsDir, getChatDir, stateDir, toolsDir } from "../../runtime/paths.js";
+import { arisaHomeDir, artifactsDir, 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) {
+export function buildAgentRuntimeContext() {
   return [
     `arisaHomeDir: ${arisaHomeDir}`,
     `arisaInstallDir: ${arisaInstallDir}`,
     `bundledToolsDir: ${bundledToolsDir}`,
     `userToolsDir: ${toolsDir}`,
     `artifactsDir: ${artifactsDir}`,
-    `stateDir: ${stateDir}`,
-    `chatWorkspaceDir: ${getChatDir(chatId)}`
+    `stateDir: ${stateDir}`
   ].join("\n");
 }

package/src/index.js

@@ -5,6 +5,7 @@ import { createApp } from "./runtime/create-app.js";
 import { createLogger } from "./runtime/logger.js";
 import { getServiceStatus, registerServiceProcess, startService, stopService } from "./runtime/service-manager.js";
 import { flushArisaHome } from "./runtime/flush.js";
+import { installPiPackage, removePiPackage } from "./runtime/pi-package-manager.js";
 
 const args = process.argv.slice(2);
 const command = args.find((arg) => !arg.startsWith("--")) || "run";
@@ -83,6 +84,28 @@ async function main() {
     return;
   }
 
+  if (command === "install") {
+    const source = args.filter((arg) => !arg.startsWith("--")).slice(1)[0];
+    if (!source) {
+      console.log("Usage: arisa install <pi-package-source>");
+      return;
+    }
+    const result = await installPiPackage(source);
+    process.exitCode = result.ok ? 0 : result.code;
+    return;
+  }
+
+  if (command === "remove") {
+    const source = args.filter((arg) => !arg.startsWith("--")).slice(1)[0];
+    if (!source) {
+      console.log("Usage: arisa remove <pi-package-source>");
+      return;
+    }
+    const result = await removePiPackage(source);
+    process.exitCode = result.ok ? 0 : result.code;
+    return;
+  }
+
   await runForeground();
 }
 

package/src/runtime/paths.js

@@ -9,15 +9,9 @@ export const servicePidFile = path.join(stateDir, "arisa.pid");
 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(arisaHomeDir, "chats");
 export const toolsDir = path.join(arisaHomeDir, "tools");
 export const tmpDir = path.join(arisaHomeDir, "tmp");
 
-export function getChatDir(chatId) {
-  return path.join(chatsDir, String(chatId));
-}
-
 export function getToolDir(toolName) {
   return path.join(toolsDir, toolName);
 }
@@ -41,8 +35,6 @@ export function getToolTmpDir(toolName) {
 export async function ensureArisaHome() {
   await mkdir(stateDir, { recursive: true });
   await mkdir(artifactsDir, { recursive: true });
-  await mkdir(piAgentDir, { recursive: true });
-  await mkdir(chatsDir, { recursive: true });
   await mkdir(toolsDir, { recursive: true });
   await mkdir(tmpDir, { recursive: true });
 }

package/src/runtime/pi-package-manager.js

@@ -0,0 +1,49 @@
+import { DefaultPackageManager, SettingsManager } from "@mariozechner/pi-coding-agent";
+import { arisaHomeDir } from "./paths.js";
+
+function createPackageManager() {
+  const settingsManager = SettingsManager.create(arisaHomeDir, arisaHomeDir);
+  const packageManager = new DefaultPackageManager({
+    cwd: arisaHomeDir,
+    agentDir: arisaHomeDir,
+    settingsManager
+  });
+
+  packageManager.setProgressCallback((event) => {
+    if (event.type === "start") {
+      process.stdout.write(`${event.message}\n`);
+    }
+  });
+
+  return packageManager;
+}
+
+export async function installPiPackage(source) {
+  const packageManager = createPackageManager();
+
+  try {
+    await packageManager.installAndPersist(source, { local: false });
+    console.log(`Installed ${source}`);
+    return { ok: true, code: 0 };
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return { ok: false, code: 1 };
+  }
+}
+
+export async function removePiPackage(source) {
+  const packageManager = createPackageManager();
+
+  try {
+    const removed = await packageManager.removeAndPersist(source, { local: false });
+    if (!removed) {
+      console.error(`No matching package found for ${source}`);
+      return { ok: false, code: 1 };
+    }
+    console.log(`Removed ${source}`);
+    return { ok: true, code: 0 };
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return { ok: false, code: 1 };
+  }
+}

package/src/transport/telegram/bot.js

@@ -1,4 +1,5 @@
 import { Bot, InputFile } from "grammy";
+import path from "node:path";
 import { authorizeChat } from "./auth.js";
 import { captureIncomingArtifact } from "./media.js";
 import { renderTelegramHtml, splitTelegramText } from "./text-format.js";
@@ -146,10 +147,28 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, a
     return buildPrompt({ ctx, artifact, transcript });
   }
 
-  async function sendTextReply(send, chatId, text) {
+  async function sendTextReply({ sendText, sendDocument, chatId, text }) {
+    const attachmentThreshold = 12000;
+
+    if (text.length > attachmentThreshold) {
+      logger?.log("telegram", `sending long reply as markdown attachment for chat ${chatId}`);
+      const artifact = await artifactStore.createGeneratedFile({
+        fileName: `reply-${Date.now()}.md`,
+        content: text,
+        kind: "document",
+        mimeType: "text/markdown",
+        source: { type: "assistant", chatId },
+        metadata: { delivery: "telegram-document" }
+      });
+      await sendDocument(new InputFile(artifact.path, path.basename(artifact.path)), {
+        caption: "Response attached as Markdown."
+      });
+      return;
+    }
+
     logger?.log("telegram", `sending text reply for chat ${chatId}`);
     for (const chunk of splitTelegramText(text)) {
-      await send(renderTelegramHtml(chunk), { parse_mode: "HTML" });
+      await sendText(renderTelegramHtml(chunk), { parse_mode: "HTML" });
     }
   }
 
@@ -167,7 +186,12 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, a
       const { session } = await agentManager.getSessionContext(ctx.chat.id, telegram);
       const text = await collectText(session, prompt);
       if (text) {
-        await sendTextReply((message, extra) => ctx.reply(message, extra), ctx.chat.id, text);
+        await sendTextReply({
+          sendText: (message, extra) => ctx.reply(message, extra),
+          sendDocument: (file, extra) => ctx.replyWithDocument(file, extra),
+          chatId: ctx.chat.id,
+          text
+        });
       }
     });
   }
@@ -260,7 +284,12 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, a
           ].filter(Boolean).join("\n");
           const text = await collectText(session, welcomePrompt);
           if (text) {
-            await sendTextReply((message, extra) => bot.api.sendMessage(chatId, message, extra), chatId, text);
+            await sendTextReply({
+              sendText: (message, extra) => bot.api.sendMessage(chatId, message, extra),
+              sendDocument: (file, extra) => bot.api.sendDocument(chatId, file, extra),
+              chatId,
+              text
+            });
           }
         } catch (error) {
           logger?.log("telegram", `startup message failed for chat ${chatId}: ${error instanceof Error ? error.message : String(error)}`);