@kairyou/agent-tools 0.12.0 → 0.13.0

package/integrations/log/opencode-plugin.mjs

@@ -0,0 +1,137 @@
+// OpenCode adapter for the log capability: translates plugin events into the
+// hook payloads dist/log/hook.mjs consumes, so both agents share one recorder.
+//
+// Verified against a real OpenCode run: chat.message carries the user prompt,
+// tool.execute.after carries absolute file paths in output.metadata.files, and
+// the assistant's final text arrives as message.part.updated parts belonging
+// to messages that message.updated announced as role=assistant.
+
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HOOK = path.join(path.dirname(fileURLToPath(import.meta.url)), "hook.mjs");
+
+// Sends run strictly one after another: the hook does an unlocked
+// read-modify-write on the day state, so parallel hook processes from the
+// same adapter would drop each other's events.
+let sendQueue = Promise.resolve();
+
+function send(payload) {
+  sendQueue = sendQueue.then(
+    () =>
+      new Promise((resolve) => {
+        try {
+          // OpenCode is a Bun single binary, so process.execPath points at
+          // opencode.exe; the hook needs the node on PATH (required >= 22 anyway).
+          const child = spawn("node", [HOOK], {
+            stdio: ["pipe", "ignore", "ignore"],
+            windowsHide: true,
+          });
+          child.on("error", () => resolve());
+          child.on("exit", () => resolve());
+          child.stdin.write(JSON.stringify(payload));
+          child.stdin.end();
+        } catch {
+          // Logging must never break the session.
+          resolve();
+        }
+      })
+  );
+}
+
+export const AgentToolsLog = async ({ directory, project } = {}) => {
+  const cwd = directory || project?.worktree || process.cwd();
+  const assistantMessageIds = new Set();
+  const lastAssistantText = new Map();
+
+  return {
+    "chat.message": async (_input, output) => {
+      const message = output?.message;
+      if (message?.role !== "user") return;
+      const text = (output?.parts || [])
+        .filter((part) => part?.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+      if (!text.trim()) return;
+      send({
+        hook_event_name: "UserPromptSubmit",
+        session_id: message.sessionID,
+        cwd,
+        prompt: text,
+      });
+    },
+    "tool.execute.before": async (input, output) => {
+      const tool = String(input?.tool || "");
+      if (tool === "bash") return;
+      const args = output?.args;
+      if (!args || typeof args !== "object") return;
+      // Forwarded so the hook can snapshot a baseline for the detailed diff;
+      // tools whose args carry no file path (such as apply_patch) are simply
+      // skipped there and their diff stays "unknown".
+      send({
+        hook_event_name: "PreToolUse",
+        session_id: input?.sessionID,
+        cwd,
+        tool_name: tool === "write" ? "Write" : "Edit",
+        tool_input: args,
+      });
+    },
+    "tool.execute.after": async (input, output) => {
+      const sessionId = input?.sessionID;
+      const tool = String(input?.tool || "");
+      if (tool === "bash") {
+        send({
+          hook_event_name: "PostToolUse",
+          session_id: sessionId,
+          cwd,
+          tool_name: "Bash",
+          tool_input: { command: String(input?.args?.command || "") },
+        });
+        return;
+      }
+      const files = output?.metadata?.files;
+      if (!Array.isArray(files)) return;
+      for (const file of files) {
+        if (!file?.filePath) continue;
+        send({
+          hook_event_name: "PostToolUse",
+          session_id: sessionId,
+          cwd,
+          tool_name: tool === "write" ? "Write" : "Edit",
+          tool_input: { file_path: file.filePath },
+        });
+      }
+    },
+    event: async ({ event }) => {
+      const type = event?.type;
+      const properties = event?.properties || {};
+      if (type === "message.updated") {
+        if (properties.info?.role === "assistant") assistantMessageIds.add(properties.info.id);
+        return;
+      }
+      if (type === "message.part.updated") {
+        const part = properties.part;
+        if (part?.type === "text" && assistantMessageIds.has(part.messageID)) {
+          lastAssistantText.set(part.sessionID, String(part.text || ""));
+        }
+        return;
+      }
+      if (type === "session.idle") {
+        send({
+          hook_event_name: "Stop",
+          session_id: properties.sessionID,
+          cwd,
+          last_assistant_message: lastAssistantText.get(properties.sessionID) || "",
+        });
+        // Cleared per turn: a cancelled or text-less next turn must not
+        // inherit this turn's summary as its own result.
+        lastAssistantText.delete(properties.sessionID);
+        return;
+      }
+      if (type === "session.deleted") {
+        lastAssistantText.delete(properties.sessionID);
+      }
+    },
+  };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kairyou/agent-tools",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Reusable Agent Skills, plus integrations (statusline, provider usage, vision) that install into Codex, Claude Code, and opencode.",
   "license": "MIT",
   "repository": {

package/scripts/build.mjs

@@ -35,6 +35,12 @@ const TARGETS = {
       cli: path.join(ROOT, "integrations", "vision", "lib", "cli.mjs"),
     },
   },
+  log: {
+    entryPoints: {
+      hook: path.join(ROOT, "integrations", "log", "hook.mjs"),
+      "opencode-plugin": path.join(ROOT, "integrations", "log", "opencode-plugin.mjs"),
+    },
+  },
 };
 
 // Repo-shipped usage routes (a fork can commit integrations/usage/routes/*.mjs

package/scripts/install.mjs

@@ -7,19 +7,20 @@
 //   statusline  Claude Code statusLine script (claude only).
 //   usage       Active API provider quota/balance (all agents).
 //   vision      inspect_image MCP server + at-vision skill (all agents).
+//   log         AI session work log via agent hooks (all agents).
 //
 // Standalone commands (dispatched before capability parsing):
 //   inspect-image <path|url> --question "..."   Human diagnostic for vision.
 //   mcp-vision                                  Run the vision MCP stdio server.
 //
 // Targets:
-//   claude   -> ~/.claude/settings.json (statusLine key)
+//   claude   -> ~/.claude/settings.json (statusLine key + log hooks)
 //               + ~/.claude/skills/at-usage
 //               ~/.claude.json (vision MCP) + ~/.claude/skills (at-vision)
-//   codex    -> ~/.codex/hooks.json (standalone hooks file)
+//   codex    -> ~/.codex/hooks.json (usage + log hooks)
 //               + ~/.agents/skills/at-usage
 //               ~/.codex/config.toml (vision MCP) + ~/.agents/skills (at-vision)
-//   opencode -> ~/.config/opencode/ (server + TUI plugins,
+//   opencode -> ~/.config/opencode/ (usage + log plugins,
 //               vision MCP in opencode.json + skills/at-vision)
 // Runtime scripts are copied into ~/.agent-tools so this installer can be
 // run via npx from GitHub without requiring a persistent local clone.
@@ -69,6 +70,8 @@ const PACKAGE_VERSION = (() => {
 // Everything copied into ~/.agent-tools is built output from dist/ (see
 // scripts/build.mjs); integrations/ holds the sources.
 const SOURCE = {
+  logHook: path.join(REPO_ROOT, "dist", "log", "hook.mjs"),
+  logOpencodePlugin: path.join(REPO_ROOT, "dist", "log", "opencode-plugin.mjs"),
   codexUsageHook: path.join(REPO_ROOT, "dist", "usage", "codex-hook.mjs"),
   usageScript: path.join(REPO_ROOT, "dist", "usage", "core.mjs"),
   usageCli: path.join(REPO_ROOT, "dist", "usage", "cli.mjs"),
@@ -78,6 +81,8 @@ const SOURCE = {
   opencodeUsageTui: path.join(REPO_ROOT, "dist", "usage", "opencode-tui.mjs"),
 };
 const RUNTIME = {
+  logHook: path.join(INSTALL_ROOT, "dist", "log", "hook.mjs"),
+  logOpencodePlugin: path.join(INSTALL_ROOT, "dist", "log", "opencode-plugin.mjs"),
   codexUsageHook: path.join(INSTALL_ROOT, "dist", "usage", "codex-hook.mjs"),
   usageScript: path.join(INSTALL_ROOT, "dist", "usage", "core.mjs"),
   usageCli: path.join(INSTALL_ROOT, "dist", "usage", "cli.mjs"),
@@ -86,12 +91,12 @@ const RUNTIME = {
   opencodeUsagePlugin: path.join(INSTALL_ROOT, "dist", "usage", "opencode-plugin.mjs"),
   opencodeUsageTui: path.join(INSTALL_ROOT, "dist", "usage", "opencode-tui.mjs"),
 };
-const ALL_CAPS = ["statusline", "usage", "vision"];
+const ALL_CAPS = ["statusline", "usage", "vision", "log"];
 const ALL_AGENTS = ["claude", "codex", "opencode"];
 const AGENT_CAPS = {
-  claude: ["statusline", "usage", "vision"],
-  codex: ["usage", "vision"],
-  opencode: ["usage", "vision"],
+  claude: ["statusline", "usage", "vision", "log"],
+  codex: ["usage", "vision", "log"],
+  opencode: ["usage", "vision", "log"],
 };
 const VISION_MCP_NAME = "agent-tools-vision";
 const VISION_SKILL_NAME = "at-vision";
@@ -233,6 +238,13 @@ function installRuntimeAssets(opts) {
     addFile(SOURCE.usageScript, RUNTIME.usageScript);
     addFile(SOURCE.config, RUNTIME.config, { mergeJsonc: true });
   }
+  if (wants(opts, "log")) {
+    addFile(SOURCE.logHook, RUNTIME.logHook);
+    if (opts.agents.includes("opencode")) {
+      addFile(SOURCE.logOpencodePlugin, RUNTIME.logOpencodePlugin);
+    }
+    addFile(SOURCE.config, RUNTIME.config, { mergeJsonc: true });
+  }
   if (wants(opts, "usage")) {
     if (opts.agents.includes("codex")) {
       addFile(SOURCE.codexUsageHook, RUNTIME.codexUsageHook);
@@ -446,6 +458,74 @@ function applyProviderUsage(cfg, { remove }) {
   if (Object.keys(cfg.hooks).length === 0) delete cfg.hooks;
 }
 
+// ---- Log capability: agent hooks running dist/log/hook.mjs, identified by
+// command signature (no meta key, mirroring the codex usage hooks). ----
+
+const LOG_EVENTS = [
+  ["UserPromptSubmit", ""],
+  ["PreToolUse", "Write|Edit|MultiEdit"],
+  ["PostToolUse", "Write|Edit|MultiEdit|Bash"],
+  ["Stop", ""],
+];
+
+// Exact match against the command this installer writes: anything else, even a
+// user's own .../dist/log/hook.mjs, is not ours and must survive uninstall.
+function isOurLogEntry(entry) {
+  const expected = nodeCmd(RUNTIME.logHook);
+  return (
+    entry &&
+    Array.isArray(entry.hooks) &&
+    entry.hooks.some((h) => h?.command === expected)
+  );
+}
+
+// Claude filters tool events via matchers; Codex hooks.json has no matcher
+// concept, so there the hook filters by tool name itself.
+function applyLogHooks(cfg, { remove, matchers }) {
+  cfg.hooks = cfg.hooks || {};
+  for (const [event, matcher] of LOG_EVENTS) {
+    const entries = (cfg.hooks[event] || []).filter((entry) => !isOurLogEntry(entry));
+    if (!remove) {
+      const entry = {
+        hooks: [{ type: "command", command: nodeCmd(RUNTIME.logHook), timeout: 30 }],
+      };
+      if (matchers && matcher) entry.matcher = matcher;
+      entries.push(entry);
+    }
+    if (entries.length > 0) cfg.hooks[event] = entries;
+    else delete cfg.hooks[event];
+  }
+  if (Object.keys(cfg.hooks).length === 0) delete cfg.hooks;
+}
+
+function runClaudeLog(opts) {
+  const settings = opts.settings || path.join(os.homedir(), ".claude", "settings.json");
+  console.log(`claude log: ${settings}`);
+  const cfg = readJson(settings);
+  applyLogHooks(cfg, { remove: opts.uninstall, matchers: true });
+  writeJson(settings, cfg, opts.dryRun);
+  console.log(opts.uninstall ? "  - log" : "  + log (session work log hooks)");
+}
+
+function runCodexLog(opts) {
+  const file = opts.codexHooks || path.join(os.homedir(), ".codex", "hooks.json");
+  console.log(`codex log: ${file}`);
+  const cfg = readJson(file);
+  applyLogHooks(cfg, { remove: opts.uninstall, matchers: false });
+  if (opts.uninstall && Object.keys(cfg).length === 0 && fs.existsSync(file)) {
+    removeFile(file, opts.dryRun);
+  } else {
+    writeJson(file, cfg, opts.dryRun);
+  }
+  console.log(opts.uninstall ? "  - log" : "  + log (session work log hooks)");
+  if (!opts.uninstall && !opts.dryRun) {
+    console.log(
+      "  NOTE: Codex will not run this hook until you trust it — run `/hooks` " +
+        "inside Codex and approve the agent-tools hooks."
+    );
+  }
+}
+
 // ---- Vision capability helpers. ----
 
 // The installed tree mirrors the package tree, so the bundled runtime lands in
@@ -828,6 +908,7 @@ function runClaudeVision(opts) {
 
 function runClaude(opts) {
   if (wants(opts, "vision")) runClaudeVision(opts);
+  if (wants(opts, "log")) runClaudeLog(opts);
   if (wants(opts, "usage")) {
     const skillsDir = opts.claudeSkillsDir || path.join(os.homedir(), ".claude", "skills");
     console.log(`claude usage: ${skillsDir}`);
@@ -891,6 +972,7 @@ function runCodexVision(opts) {
 
 function runCodex(opts) {
   if (wants(opts, "vision")) runCodexVision(opts);
+  if (wants(opts, "log")) runCodexLog(opts);
   if (!wants(opts, "usage")) {
     return;
   }
@@ -933,6 +1015,26 @@ function runCodex(opts) {
 // usage after a session goes idle. A TUI plugin displays the shared snapshot. ----
 
 const OPENCODE_STUB_NAME = "agent-tools-usage.js";
+const OPENCODE_LOG_STUB_NAME = "agent-tools-log.js";
+
+function runOpencodeLog(opts) {
+  const configDir = opencodeConfigDir(opts);
+  const stub = path.join(configDir, "plugins", OPENCODE_LOG_STUB_NAME);
+  console.log(`opencode log: ${stub}`);
+  if (opts.uninstall) {
+    if (fs.existsSync(stub)) removeFile(stub, opts.dryRun);
+    else console.log("  no agent-tools log plugin found; nothing to remove.");
+    console.log("  - log");
+    return;
+  }
+  const target = pathToFileURL(RUNTIME.logOpencodePlugin).href;
+  const contents =
+    "// Generated by agent-tools installer; do not edit.\n" +
+    `export { AgentToolsLog } from ${JSON.stringify(target)};\n`;
+  writeText(stub, contents, opts.dryRun);
+  console.log("  + log (session work log plugin)");
+  if (!opts.dryRun) console.log("  NOTE: restart opencode to load the agent-tools log plugin.");
+}
 
 function opencodeConfigDir(opts) {
   return (
@@ -993,6 +1095,7 @@ function runOpencodeVision(opts) {
 
 function runOpencode(opts) {
   if (wants(opts, "vision")) runOpencodeVision(opts);
+  if (wants(opts, "log")) runOpencodeLog(opts);
   if (!wants(opts, "usage")) {
     return;
   }

package/skills/workflow/at-daily-log/SKILL.md

@@ -54,6 +54,15 @@ their dates are unverifiable, and a project left dirty for weeks would reappear
 progress every day. User-provided non-code work must remain clearly identified as user
 context.
 
+`~/.agent-tools/config.jsonc` may also carry `log.output`, an automatically recorded
+AI session log, separate from `dailyLog.output`. It is a markdown file with dated
+entries, or a directory holding one `<date>.md` report per day; entries under
+`log.projects` may route their sessions to their own `output`, so check those paths
+too. Read the day's content as supplementary evidence, as it captures work that
+produced no commits, such as troubleshooting or research sessions. Merge, do not
+duplicate, work already backed by commits; when the key or the day's content is
+absent, skip this entirely.
+
 ## Output
 
 Match the user's language:
@@ -85,7 +94,7 @@ write request, writes after previewing the entry. Resolve the destination in ord
 3. no destination: return the draft without writing.
 
 Read the destination before editing. Wrap each date's generated content in that date's
-own markers, `<!-- log:2026-07-31:start 5,a1b2c3d -->` / `<!-- log:2026-07-31:end -->`,
+own markers, `<!-- daily-log:2026-07-31:start 5,a1b2c3d -->` / `<!-- daily-log:2026-07-31:end -->`,
 where the start marker stores the day's commit count and newest commit hash across the
 scanned projects; the date line and every line outside the markers belong to the user.
 Refresh an existing block when either value changed or the user explicitly asks;
@@ -96,9 +105,9 @@ user's lines instead of editing them. Do not duplicate the date. Insert a new da
 among the existing dated entries at its date-order position, inferring ascending or
 descending from the dates already present (ascending when that is ambiguous); content
 above or below the dated entries, such as notes or todo lists, stays where it is. On duplicate or
-unpaired markers, stop and propose the edit instead of writing. When Git shows no
-activity, leave the file unchanged and say so; the user can add a manual entry
-themselves. Recording a range applies these rules to each day's block independently.
+unpaired markers, stop and propose the edit instead of writing. When neither Git nor
+the session log shows activity for the day, leave the file unchanged and say so; the
+user can add a manual entry themselves. Recording a range applies these rules to each day's block independently.
 
 Scheduling is separate; set it up only when the user asks. Prefer the OS scheduler
 (Task Scheduler, cron, launchd) over agent-internal timers, which stop with the agent:

package/skills/workflow/at-self-eval/SKILL.md

@@ -57,8 +57,13 @@ Git jargon. Do not show commit counts or a generic source line.
 ## Optional logs
 
 A pasted daily/weekly log or explicit file path provides business context. If neither is
-supplied, optionally read `dailyLog.output` from config. Explicit conversation input
-always wins; a missing log is non-fatal.
+supplied, optionally read `dailyLog.output` and `log.output` (an automatically recorded
+AI session log; a dated markdown file, or a directory of per-day `<date>.md` reports,
+of which read the dates inside the window; entries under `log.projects` may add their
+own `output` paths, check those too) from `~/.agent-tools/config.jsonc`; the
+latter also captures work that never produced commits,
+such as troubleshooting or research sessions. Explicit conversation input always wins;
+a missing key or file is non-fatal.
 
 Commit-backed items may be summarized directly. Keep log-only work separate for user
 confirmation; include it only after confirmation, using only dates stated in the log or