arisa 3.0.14 → 3.1.4

package/src/core/artifacts/artifact-store.js

@@ -1,39 +1,44 @@
 import { mkdir, readFile, writeFile, copyFile } from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
-import { artifactsDir as rootDir, artifactsIndexFile as indexFile } from "../../runtime/paths.js";
-
-async function loadIndex() {
-  try {
-    return JSON.parse(await readFile(indexFile, "utf8"));
-  } catch {
-    return [];
-  }
-}
-
-async function saveIndex(items) {
-  await mkdir(path.dirname(indexFile), { recursive: true });
-  await writeFile(indexFile, `${JSON.stringify(items, null, 2)}\n`, "utf8");
-}
+import { getChatArtifactsDir, getChatArtifactsIndexFile } from "../../runtime/paths.js";
 
 function id() {
   return crypto.randomUUID();
 }
 
-export class ArtifactStore {
-  constructor() {
+class ChatArtifactStore {
+  constructor(chatId) {
+    this.chatId = String(chatId);
+    this.rootDir = getChatArtifactsDir(this.chatId);
+    this.indexFile = getChatArtifactsIndexFile(this.chatId);
     this.items = null;
   }
 
+  async reload() {
+    try {
+      this.items = JSON.parse(await readFile(this.indexFile, "utf8"));
+    } catch {
+      this.items = [];
+    }
+  }
+
   async init() {
-    if (!this.items) this.items = await loadIndex();
-    await mkdir(rootDir, { recursive: true });
+    await mkdir(this.rootDir, { recursive: true });
+    if (!this.items) await this.reload();
+  }
+
+  async saveIndex() {
+    await mkdir(path.dirname(this.indexFile), { recursive: true });
+    await writeFile(this.indexFile, `${JSON.stringify(this.items, null, 2)}\n`, "utf8");
   }
 
   async createText({ text, mimeType = "text/plain", source, metadata = {} }) {
     await this.init();
+    await this.reload();
     const artifact = {
       id: id(),
+      chatId: this.chatId,
       kind: "text",
       mimeType,
       text,
@@ -42,19 +47,21 @@ export class ArtifactStore {
       createdAt: new Date().toISOString()
     };
     this.items.push(artifact);
-    await saveIndex(this.items);
+    await this.saveIndex();
     return artifact;
   }
 
   async createFromFile({ originalPath, fileName, kind, mimeType, source, metadata = {} }) {
     await this.init();
+    await this.reload();
     const artifactId = id();
-    const dir = path.join(rootDir, artifactId);
+    const dir = path.join(this.rootDir, artifactId);
     await mkdir(dir, { recursive: true });
     const destPath = path.join(dir, fileName);
     await copyFile(originalPath, destPath);
     const artifact = {
       id: artifactId,
+      chatId: this.chatId,
       kind,
       mimeType,
       path: destPath,
@@ -63,19 +70,21 @@ export class ArtifactStore {
       createdAt: new Date().toISOString()
     };
     this.items.push(artifact);
-    await saveIndex(this.items);
+    await this.saveIndex();
     return artifact;
   }
 
   async createGeneratedFile({ fileName, content, kind, mimeType, source, metadata = {} }) {
     await this.init();
+    await this.reload();
     const artifactId = id();
-    const dir = path.join(rootDir, artifactId);
+    const dir = path.join(this.rootDir, artifactId);
     await mkdir(dir, { recursive: true });
     const destPath = path.join(dir, fileName);
     await writeFile(destPath, content);
     const artifact = {
       id: artifactId,
+      chatId: this.chatId,
       kind,
       mimeType,
       path: destPath,
@@ -84,17 +93,33 @@ export class ArtifactStore {
       createdAt: new Date().toISOString()
     };
     this.items.push(artifact);
-    await saveIndex(this.items);
+    await this.saveIndex();
     return artifact;
   }
 
-  async get(id) {
+  async get(artifactId) {
     await this.init();
-    return this.items.find((item) => item.id === id) || null;
+    await this.reload();
+    return this.items.find((item) => item.id === artifactId) || null;
   }
 
   async listRecent(limit = 20) {
     await this.init();
+    await this.reload();
     return [...this.items].slice(-limit).reverse();
   }
 }
+
+export class ArtifactStore {
+  constructor() {
+    this.chatStores = new Map();
+  }
+
+  forChat(chatId) {
+    const key = String(chatId);
+    if (!this.chatStores.has(key)) {
+      this.chatStores.set(key, new ChatArtifactStore(key));
+    }
+    return this.chatStores.get(key);
+  }
+}

package/src/core/artifacts/normalize-for-reasoning.js

@@ -0,0 +1,91 @@
+function mimeMatches(pattern, mimeType = "") {
+  if (!pattern || !mimeType) return false;
+  if (pattern === mimeType) return true;
+  if (pattern.endsWith("/*")) return mimeType.startsWith(`${pattern.slice(0, -2)}/`);
+  return false;
+}
+
+function toolSupportsArtifact(tool, artifact) {
+  const inputs = Array.isArray(tool.input) ? tool.input : [];
+  return inputs.some((input) => mimeMatches(input, artifact.mimeType));
+}
+
+function toolProduces(tool, mimeType) {
+  const outputs = Array.isArray(tool.output) ? tool.output : [];
+  return outputs.some((output) => mimeMatches(output, mimeType));
+}
+
+function looksLikeAudioTranscriptionTool(tool) {
+  return /transcri|whisper|speech.?to.?text|audio.?to.?text/i.test(`${tool.name} ${tool.description || ""}`);
+}
+
+export function shouldNormalizeArtifactToText(artifact, desiredMimeType = "text/plain") {
+  return desiredMimeType === "text/plain"
+    && (artifact?.mimeType?.startsWith("audio/") || artifact?.mimeType?.startsWith("video/"));
+}
+
+export function selectPipeTool({ toolRegistry, artifact, desiredMimeType }) {
+  const tools = toolRegistry.list()
+    .filter((tool) => toolSupportsArtifact(tool, artifact))
+    .filter((tool) => toolProduces(tool, desiredMimeType));
+
+  if (shouldNormalizeArtifactToText(artifact, desiredMimeType)) {
+    return tools.find(looksLikeAudioTranscriptionTool) || null;
+  }
+
+  return null;
+}
+
+export async function normalizeArtifactForReasoning({
+  artifact,
+  desiredMimeType = "text/plain",
+  toolRegistry,
+  chatArtifactStore,
+  chatId
+}) {
+  if (!artifact) return { normalizedArtifact: null, toolResult: null, toolName: "" };
+
+  if (!shouldNormalizeArtifactToText(artifact, desiredMimeType)) {
+    return { normalizedArtifact: null, toolResult: null, toolName: "" };
+  }
+
+  const tool = selectPipeTool({ toolRegistry, artifact, desiredMimeType });
+  if (!tool) {
+    return {
+      normalizedArtifact: null,
+      toolResult: {
+        ok: false,
+        status: "failed",
+        error: `No registered tool can normalize ${artifact.mimeType} to ${desiredMimeType}.`
+      },
+      toolName: ""
+    };
+  }
+
+  const result = await toolRegistry.run({
+    name: tool.name,
+    request: { artifact, args: {} },
+    chatId
+  });
+
+  if (!result.ok) {
+    return { normalizedArtifact: null, toolResult: result, toolName: tool.name };
+  }
+
+  if (!result.output?.text) {
+    return {
+      normalizedArtifact: null,
+      toolResult: { ok: false, status: "failed", error: "Normalization returned no text." },
+      toolName: tool.name
+    };
+  }
+
+  const normalizedArtifact = await chatArtifactStore.createText({
+    text: result.output.text,
+    mimeType: desiredMimeType,
+    source: { type: "tool", toolName: tool.name },
+    metadata: { fromArtifactId: artifact.id, tool: tool.name, normalization: true }
+  });
+
+  return { normalizedArtifact, toolResult: result, toolName: tool.name };
+}

package/src/core/skills/skill-registry.js

@@ -0,0 +1,71 @@
+import os from "node:os";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+
+const defaultSkillsDir = path.join(os.homedir(), ".agents", "skills");
+
+function parseFrontmatter(source = "") {
+  if (!source.startsWith("---")) return {};
+  const end = source.indexOf("\n---", 3);
+  if (end === -1) return {};
+  const block = source.slice(3, end).trim();
+  const data = {};
+  for (const line of block.split("\n")) {
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (match) data[match[1]] = match[2].replace(/^['"]|['"]$/g, "");
+  }
+  return data;
+}
+
+function normalizeSkillHint(value) {
+  if (typeof value === "string") return { name: value, when: "" };
+  if (value && typeof value === "object" && value.name) {
+    return { name: String(value.name), when: String(value.when || "") };
+  }
+  return null;
+}
+
+export class SkillRegistry {
+  constructor({ skillsDir = defaultSkillsDir } = {}) {
+    this.skillsDir = skillsDir;
+    this.cache = new Map();
+  }
+
+  async get(name) {
+    const key = String(name || "").trim();
+    if (!key) return null;
+    if (this.cache.has(key)) return this.cache.get(key);
+
+    const file = path.join(this.skillsDir, key, "SKILL.md");
+    try {
+      const content = await readFile(file, "utf8");
+      const metadata = parseFrontmatter(content);
+      const skill = {
+        name: metadata.name || key,
+        description: metadata.description || "",
+        path: file,
+        content
+      };
+      this.cache.set(key, skill);
+      return skill;
+    } catch {
+      this.cache.set(key, null);
+      return null;
+    }
+  }
+
+  normalizeHints(manifest = {}) {
+    const raw = manifest.skillHints || manifest.skills || [];
+    if (!Array.isArray(raw)) return [];
+    return raw.map(normalizeSkillHint).filter(Boolean);
+  }
+
+  async resolveHints(hints = []) {
+    const resolved = [];
+    for (const hint of hints) {
+      const skill = await this.get(hint.name);
+      resolved.push({ ...hint, found: Boolean(skill), skill });
+    }
+    return resolved;
+  }
+}

package/src/core/tasks/task-store.js

@@ -27,7 +27,7 @@ function normalizeTask(task, defaults = {}) {
     createdAt: task.createdAt || new Date().toISOString(),
     updatedAt: new Date().toISOString(),
     kind: task.kind,
-    runAt: task.runAt,
+    runAt: task.runAt || new Date().toISOString(),
     payload: {
       ...(defaults.payload || {}),
       ...(task.payload || {})
@@ -56,6 +56,10 @@ export class TaskStore {
     if (!this.tasks) this.tasks = await loadTasksFile();
   }
 
+  async reload() {
+    this.tasks = await loadTasksFile();
+  }
+
   async save() {
     await saveTasksFile(this.tasks || []);
   }
@@ -77,7 +81,7 @@ export class TaskStore {
   }
 
   async claimDue(limit = 10) {
-    await this.init();
+    await this.reload();
     const now = Date.now();
     const due = [];
 
@@ -126,7 +130,7 @@ export class TaskStore {
   }
 
   async list(filter = {}) {
-    await this.init();
+    await this.reload();
     return this.tasks.filter((task) => {
       if (filter.chatId && task.payload?.chatId !== filter.chatId) return false;
       if (filter.status && task.status !== filter.status) return false;
@@ -136,12 +140,12 @@ export class TaskStore {
   }
 
   async get(taskId) {
-    await this.init();
+    await this.reload();
     return this.tasks.find((item) => item.id === taskId) || null;
   }
 
   async cancel(taskId) {
-    await this.init();
+    await this.reload();
     const index = this.tasks.findIndex((item) => item.id === taskId);
     if (index === -1) return null;
     const [task] = this.tasks.splice(index, 1);
@@ -150,7 +154,7 @@ export class TaskStore {
   }
 
   async cancelAll(filter = {}) {
-    await this.init();
+    await this.reload();
     const removed = [];
     this.tasks = this.tasks.filter((task) => {
       if (filter.chatId && task.payload?.chatId !== filter.chatId) return true;

package/src/core/tools/daemon-runtime.js

@@ -0,0 +1,167 @@
+import crypto from "node:crypto";
+import { spawn } from "node:child_process";
+import { openSync } from "node:fs";
+import { mkdir, readFile, readdir, rename, rm, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getToolStateDir } from "../../runtime/paths.js";
+
+export function daemonPaths(toolName) {
+  const root = getToolStateDir(toolName);
+  return {
+    root,
+    commandsDir: path.join(root, "commands"),
+    pidFile: path.join(root, "daemon.pid"),
+    statusFile: path.join(root, "status.json"),
+    logFile: path.join(root, "daemon.log")
+  };
+}
+
+export async function readJson(file, fallback = {}) {
+  try { return JSON.parse(await readFile(file, "utf8")); } catch { return fallback; }
+}
+
+export async function writeJson(file, value) {
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+export function isProcessAlive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+export function createDaemonRuntime({ toolName, entryPath, beforeStart = null }) {
+  const paths = daemonPaths(toolName);
+
+  async function ensure() {
+    await mkdir(paths.commandsDir, { recursive: true });
+  }
+
+  function jobPaths(id) {
+    return {
+      request: path.join(paths.commandsDir, `${id}.request.json`),
+      processing: path.join(paths.commandsDir, `${id}.processing.json`),
+      result: path.join(paths.commandsDir, `${id}.result.json`)
+    };
+  }
+
+  async function getPid() {
+    return (await readJson(paths.pidFile, {})).pid;
+  }
+
+  async function writeStatus(patch) {
+    const current = await readJson(paths.statusFile, {});
+    await writeJson(paths.statusFile, { ...current, ...patch, updatedAt: new Date().toISOString() });
+  }
+
+  async function clearJobs() {
+    await rm(paths.commandsDir, { recursive: true, force: true });
+    await mkdir(paths.commandsDir, { recursive: true });
+  }
+
+  async function start() {
+    await ensure();
+    const pid = await getPid();
+    if (isProcessAlive(pid)) return pid;
+
+    await clearJobs();
+    if (beforeStart) await beforeStart();
+    const out = openSync(paths.logFile, "a");
+    const child = spawn(process.execPath, [entryPath, "daemon"], {
+      detached: true,
+      stdio: ["ignore", out, out],
+      env: process.env
+    });
+    child.unref();
+    await writeJson(paths.pidFile, { pid: child.pid, startedAt: new Date().toISOString() });
+    return child.pid;
+  }
+
+  async function stop() {
+    const pid = await getPid();
+    if (isProcessAlive(pid)) process.kill(pid, "SIGTERM");
+    await rm(paths.pidFile, { force: true });
+  }
+
+  async function waitReady({ timeoutMs = 120000, readyStates = ["ready"] } = {}) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const status = await readJson(paths.statusFile, {});
+      const pid = await getPid();
+      if (readyStates.includes(status.state) && isProcessAlive(pid)) return status;
+      if (status.state === "error") throw new Error(status.message || `${toolName} daemon failed`);
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    throw new Error(`${toolName} daemon was not ready after ${timeoutMs}ms`);
+  }
+
+  async function submit(payload, { timeoutMs = 180000, readyTimeoutMs = 120000 } = {}) {
+    await start();
+    await waitReady({ timeoutMs: readyTimeoutMs });
+    const id = crypto.randomUUID();
+    const files = jobPaths(id);
+    await writeJson(files.request, { id, ...payload });
+
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const result = await readJson(files.result, null);
+      if (result) {
+        await unlink(files.result).catch(() => {});
+        if (!result.ok) throw new Error(result.error || `${toolName} job failed`);
+        return result.output || {};
+      }
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new Error(`${toolName} job timed out after ${timeoutMs}ms`);
+  }
+
+  async function claimNext() {
+    await ensure();
+    const files = (await readdir(paths.commandsDir)).filter((file) => file.endsWith(".request.json"));
+    for (const file of files) {
+      const id = file.replace(/\.request\.json$/, "");
+      const item = jobPaths(id);
+      try {
+        await rename(item.request, item.processing);
+        return { id, ...item, payload: await readJson(item.processing, null) };
+      } catch {}
+    }
+    return null;
+  }
+
+  async function complete(job, output) {
+    await writeJson(job.result, { ok: true, output });
+    await unlink(job.processing).catch(() => {});
+  }
+
+  async function fail(job, error) {
+    await writeJson(job.result, { ok: false, error: error?.message || String(error) });
+    await unlink(job.processing).catch(() => {});
+  }
+
+  async function workLoop({ processJob, idleTimeoutMs = 0, intervalMs = 250 }) {
+    let lastActivity = Date.now();
+    setInterval(async () => {
+      try {
+        const job = await claimNext();
+        if (job) {
+          lastActivity = Date.now();
+          try {
+            await complete(job, await processJob(job.payload));
+          } catch (error) {
+            await fail(job, error);
+          }
+          lastActivity = Date.now();
+        }
+        if (idleTimeoutMs > 0 && Date.now() - lastActivity > idleTimeoutMs) {
+          await writeStatus({ state: "stopped", message: "Idle timeout reached" });
+          process.exit(0);
+        }
+      } catch (error) {
+        await writeStatus({ state: "error", message: error?.message || String(error) });
+      }
+    }, intervalMs);
+  }
+
+  return { paths, ensure, getPid, writeStatus, start, stop, waitReady, submit, workLoop };
+}

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

@@ -1,6 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { getToolConfigPath } from "../../runtime/paths.js";
+import { getToolConfigPath, getChatToolConfigPath } from "../../runtime/paths.js";
 
 export function parseConfigModule(source) {
   const normalized = source.replace(/^export\s+default/, "return");
@@ -21,14 +21,22 @@ export async function readConfigModule(filePath, fallback = {}) {
   }
 }
 
-export async function loadToolConfig(toolName, defaults = {}) {
-  const configPath = getToolConfigPath(toolName);
-  const stored = await readConfigModule(configPath, {});
-  return { ...defaults, ...stored };
+export async function loadToolConfig(toolName, defaults = {}, chatId = null) {
+  const globalPath = getToolConfigPath(toolName);
+  const globalStored = await readConfigModule(globalPath, {});
+  const merged = { ...defaults, ...globalStored };
+
+  if (chatId == null) return merged;
+
+  const chatPath = getChatToolConfigPath(chatId, toolName);
+  const chatStored = await readConfigModule(chatPath, {});
+  return { ...merged, ...chatStored };
 }
 
-export async function writeToolConfig(toolName, config) {
-  const configPath = getToolConfigPath(toolName);
+export async function writeToolConfig(toolName, config, chatId = null) {
+  const configPath = chatId != null
+    ? getChatToolConfigPath(chatId, toolName)
+    : getToolConfigPath(toolName);
   await mkdir(path.dirname(configPath), { recursive: true });
   await writeFile(configPath, serializeConfigModule(config), "utf8");
   return configPath;