@ariso-ai/ari-hooks 0.1.4 → 0.1.5

package/README.md

@@ -38,6 +38,7 @@ Existing settings and hooks are preserved; running it again is a no-op.
 | Command | What it does |
 |---|---|
 | `ari-hooks install` | Login (if needed) + set up hooks in the current folder |
+| `ari-hooks uninstall` | Remove the hooks from `./.claude/settings.json` |
 | `ari-hooks login` | Browser login, stores the API token |
 | `ari-hooks init` | Just add the hooks to `./.claude/settings.json` (no login) |
 | `ari-hooks config` | Show configured URLs and login state |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ariso-ai/ari-hooks",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Set up Claude Code hooks that share your requests and their outcomes with Ari",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -1,5 +1,5 @@
 import { login, logout, status } from './login.js';
-import { init } from './init.js';
+import { init, uninstall } from './init.js';
 import { runHook } from './hooks.js';
 import { loadConfig, setUrls, showConfig } from './config.js';
 
@@ -7,6 +7,7 @@ const USAGE = `ari-hooks — share your Claude Code activity with Ari
 
 Usage:
   ari-hooks install      Log in (if needed) and set up hooks in the current folder
+  ari-hooks uninstall    Remove the hooks from ./.claude/settings.json
   ari-hooks login        Log in via the browser and store an API token
   ari-hooks init         Just add the hooks to ./.claude/settings.json (no login)
   ari-hooks config       Show the configured URLs and login state
@@ -73,6 +74,9 @@ export async function main(argv) {
     case 'init':
       init();
       return;
+    case 'uninstall':
+      uninstall();
+      return;
     case 'hook':
       await runHook(rest[1]);
       return;

package/src/hooks.js

@@ -11,6 +11,14 @@ import { configDir, loadConfig, getApiUrl } from './config.js';
 
 const MAX_TEXT_LENGTH = 100_000;
 const SEND_TIMEOUT_MS = 15_000;
+// Claude Code can fire Stop while the final assistant message is still being
+// flushed to the transcript; poll until the tail settles (or give up).
+const OUTCOME_POLL_INTERVAL_MS = 150;
+const OUTCOME_SETTLE_TIMEOUT_MS = Number(
+  process.env.ARI_HOOKS_SETTLE_TIMEOUT_MS ?? 5_000
+);
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 const sessionsDir = () => join(configDir(), 'sessions');
 const sessionPath = (sessionId) =>
@@ -61,29 +69,62 @@ async function onUserPromptSubmit(input) {
   saveSession(input.session_id, session);
 }
 
+function assistantText(entry) {
+  if (entry.type !== 'assistant' || !Array.isArray(entry.message?.content)) {
+    return '';
+  }
+  return entry.message.content
+    .filter((block) => block.type === 'text' && block.text)
+    .map((block) => block.text)
+    .join('\n')
+    .trim();
+}
+
 /**
  * Pull the final assistant text out of the transcript (JSONL). This is the
  * "outcome" — we deliberately skip the intermediate steps/tool calls.
+ *
+ * `settled` reports whether the exchange actually ends in assistant text.
+ * When the transcript instead ends at a tool call/result or a half-written
+ * line, the final message hasn't been flushed yet and `text` is only the
+ * last narration before a tool ran — the caller should re-read rather than
+ * ship that as the outcome.
  */
 function extractOutcome(transcriptPath) {
-  const lines = readFileSync(transcriptPath, 'utf8').split('\n');
-  for (let i = lines.length - 1; i >= 0; i--) {
-    if (!lines[i].trim()) continue;
-    let entry;
+  const entries = [];
+  let tailPartial = false;
+  for (const line of readFileSync(transcriptPath, 'utf8').split('\n')) {
+    if (!line.trim()) continue;
     try {
-      entry = JSON.parse(lines[i]);
+      entries.push(JSON.parse(line));
+      tailPartial = false;
     } catch {
+      tailPartial = true; // a line still being written
+    }
+  }
+
+  let settled = tailPartial ? false : null;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    // Bookkeeping entries (system, attachment, last-prompt, …) may trail
+    // the exchange; they say nothing about whether it is complete.
+    if (entry.type !== 'assistant' && entry.type !== 'user') continue;
+    let text = assistantText(entry);
+    if (!text) {
+      // A tool call/result with nothing after it: mid-turn.
+      settled ??= false;
       continue;
     }
-    if (entry.type !== 'assistant' || !entry.message?.content) continue;
-    const text = entry.message.content
-      .filter((block) => block.type === 'text' && block.text)
-      .map((block) => block.text)
-      .join('\n')
-      .trim();
-    if (text) return text;
+    // The message may span several JSONL entries (one per content block);
+    // stitch earlier blocks of the same message back on.
+    const id = entry.message?.id;
+    for (let j = i - 1; id && j >= 0 && entries[j].message?.id === id; j--) {
+      const earlier = assistantText(entries[j]);
+      if (earlier) text = `${earlier}\n${text}`;
+    }
+    return { text, settled: settled ?? true };
   }
-  return null;
+  return { text: null, settled: false };
 }
 
 const clamp = (text) =>
@@ -102,7 +143,16 @@ async function onStop(input) {
   const session = loadSession(input.session_id);
   if (session.prompts.length === 0) return;
 
-  const outcome = extractOutcome(input.transcript_path);
+  // Wait for the final assistant message to land in the transcript; on
+  // timeout fall back to the last text we did find (best effort).
+  const deadline = Date.now() + OUTCOME_SETTLE_TIMEOUT_MS;
+  let outcome;
+  for (;;) {
+    const { text, settled } = extractOutcome(input.transcript_path);
+    outcome = text;
+    if (settled || Date.now() >= deadline) break;
+    await sleep(OUTCOME_POLL_INTERVAL_MS);
+  }
   if (!outcome) return;
 
   const config = loadConfig();

package/src/init.js

@@ -1,5 +1,5 @@
 import { join } from 'node:path';
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 
 const HOOK_EVENTS = {
   SessionStart: 'ari-hooks hook session-start',
@@ -55,3 +55,58 @@ export function init(cwd = process.cwd()) {
   );
   console.log('and show suggested Ari tasks when a session starts.');
 }
+
+/**
+ * Remove the ari-hooks hook commands that init/install added to the
+ * project's Claude Code settings. The inverse of init: only ari-hooks
+ * entries are touched, everything else in the file is preserved.
+ */
+export function uninstall(cwd = process.cwd()) {
+  const settingsPath = join(cwd, '.claude', 'settings.json');
+
+  if (!existsSync(settingsPath)) {
+    console.log(`No Claude Code settings found at ${settingsPath} — nothing to remove.`);
+    return;
+  }
+
+  let settings;
+  try {
+    settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+  } catch {
+    throw new Error(
+      `${settingsPath} exists but is not valid JSON — fix or remove it, then re-run.`
+    );
+  }
+
+  const isOurs = (h) => h.command?.includes('ari-hooks hook');
+  let changed = false;
+
+  for (const [event, matchers] of Object.entries(settings.hooks ?? {})) {
+    if (!Array.isArray(matchers)) continue;
+    const kept = matchers
+      .map((matcher) => {
+        if (!(matcher.hooks ?? []).some(isOurs)) return matcher;
+        changed = true;
+        const rest = matcher.hooks.filter((h) => !isOurs(h));
+        return rest.length > 0 ? { ...matcher, hooks: rest } : null;
+      })
+      .filter(Boolean);
+    if (kept.length > 0) settings.hooks[event] = kept;
+    else delete settings.hooks[event];
+  }
+
+  if (!changed) {
+    console.log(`No Ari hooks found in ${settingsPath} — nothing to remove.`);
+    return;
+  }
+
+  if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  console.log(`✓ Ari hooks removed from ${settingsPath}`);
+  console.log(
+    'Claude Code sessions in this folder will no longer share activity with Ari.'
+  );
+}