@aria_asi/cli 0.2.0

package/src/install-hooks.ts

@@ -0,0 +1,259 @@
+// install-hooks — drops the harness gate hooks into the client's
+// ~/.claude/hooks/ directory and registers them in their settings.json.
+//
+// This is what makes @aria_asi/cli a self-installing harness. Without it,
+// clients install the CLI and have a license-aware HTTP client. With it,
+// running `aria install-hooks` once turns their Claude Code (or any
+// Claude Code Code session on that machine) into a harness-bound
+// session — every Bash, Edit, Write, NotebookEdit, and text-emit event
+// runs through cognition gates + Mizan + harness packet.
+//
+// Soldier-and-thinker (Hamza 2026-04-26 directive): the CLI is the
+// thinker (carries doctrine, gates, substrate); the LLM in Claude Code
+// is the soldier (executes under harness binding). install-hooks is
+// what wires the soldier to the thinker on the client's machine.
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync, chmodSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export interface InstallHooksOptions {
+  /** Overwrite existing hooks even if present. Default false. */
+  force?: boolean;
+  /** Override the harness URL written into settings.json env (clients with private deployments). */
+  harnessUrl?: string;
+  /** Override the home directory (used by tests). */
+  homeDir?: string;
+}
+
+export interface InstallHooksResult {
+  ok: boolean;
+  installed: string[];
+  merged: string[];
+  backupsCreated: string[];
+  settingsPath: string;
+  error?: string;
+}
+
+const HOOK_FILES = [
+  'aria-pre-tool-gate.mjs',
+  'aria-stop-gate.mjs',
+  'aria-preprompt-consult.mjs',
+];
+
+const HOOK_REGISTRATION = {
+  UserPromptSubmit: [
+    {
+      hooks: [
+        {
+          type: 'command',
+          command: 'node $HOME/.claude/hooks/aria-preprompt-consult.mjs',
+          timeout: 12,
+          statusMessage: 'Pre-consulting Aria substrate for direction...',
+        },
+      ],
+    },
+  ],
+  PreToolUse: [
+    {
+      matcher: 'Bash|Edit|Write|NotebookEdit',
+      hooks: [
+        {
+          type: 'command',
+          command: 'node $HOME/.claude/hooks/aria-pre-tool-gate.mjs',
+          timeout: 5,
+        },
+      ],
+    },
+  ],
+  Stop: [
+    {
+      hooks: [
+        {
+          type: 'command',
+          command: 'node $HOME/.claude/hooks/aria-stop-gate.mjs',
+          timeout: 5,
+        },
+      ],
+    },
+  ],
+};
+
+function bundledHooksDir(): string {
+  // The hooks/ dir is bundled in the package alongside dist/. Find it by
+  // walking upward from this file's runtime path until we hit a directory
+  // that contains both package.json (with name @aria_asi/cli) and a hooks/
+  // sibling. Robust across:
+  //   - dev: src/install-hooks.ts → ../hooks
+  //   - flat compile: dist/install-hooks.js → ../hooks
+  //   - nested compile: dist/aria-connector/src/install-hooks.js → ../../../hooks
+  //   - npm global install: /usr/lib/node_modules/@aria_asi/cli/dist/.../install-hooks.js
+  const here = fileURLToPath(import.meta.url);
+  let cur = dirname(here);
+  const tried: string[] = [];
+  for (let i = 0; i < 8; i++) {
+    const candidate = join(cur, 'hooks');
+    tried.push(candidate);
+    if (existsSync(candidate) && existsSync(join(cur, 'package.json'))) {
+      return candidate;
+    }
+    const parent = dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  throw new Error(
+    `I can't find my bundled hooks/ dir. Tried: ${tried.join(', ')}. Reinstall @aria_asi/cli or report this as a bug.`,
+  );
+}
+
+function backupExisting(target: string): string {
+  const ts = Date.now();
+  const backup = `${target}.pre-aria-install.${ts}`;
+  copyFileSync(target, backup);
+  return backup;
+}
+
+function mergeRegistrationInto(existing: Record<string, unknown>): { merged: Record<string, unknown>; mergedKeys: string[] } {
+  const mergedKeys: string[] = [];
+  const out = { ...existing };
+  if (!out.hooks || typeof out.hooks !== 'object') {
+    out.hooks = {};
+  }
+  const hooks = out.hooks as Record<string, unknown[]>;
+
+  for (const [event, ourEntries] of Object.entries(HOOK_REGISTRATION)) {
+    const existingEntries = Array.isArray(hooks[event]) ? hooks[event] : [];
+
+    // For each of our entries, append unless an entry with the same matcher
+    // and command already exists (idempotent re-install).
+    for (const ourEntry of ourEntries) {
+      const ourMatcher = (ourEntry as { matcher?: string }).matcher ?? '';
+      const ourCommands = ((ourEntry as { hooks?: Array<{ command?: string }> }).hooks ?? [])
+        .map((h) => h.command)
+        .filter((c): c is string => typeof c === 'string');
+
+      const alreadyPresent = existingEntries.some((e) => {
+        if (typeof e !== 'object' || e === null) return false;
+        const eMatcher = (e as { matcher?: string }).matcher ?? '';
+        if (eMatcher !== ourMatcher) return false;
+        const eCommands = ((e as { hooks?: Array<{ command?: string }> }).hooks ?? [])
+          .map((h) => h.command)
+          .filter((c): c is string => typeof c === 'string');
+        return ourCommands.every((c) => eCommands.includes(c));
+      });
+
+      if (!alreadyPresent) {
+        existingEntries.push(ourEntry);
+        if (!mergedKeys.includes(event)) mergedKeys.push(event);
+      }
+    }
+
+    hooks[event] = existingEntries;
+  }
+
+  return { merged: out, mergedKeys };
+}
+
+export async function installHooks(opts: InstallHooksOptions = {}): Promise<InstallHooksResult> {
+  const home = opts.homeDir ?? homedir();
+  const claudeDir = join(home, '.claude');
+  const hooksDir = join(claudeDir, 'hooks');
+  const settingsPath = join(claudeDir, 'settings.json');
+
+  const installed: string[] = [];
+  const merged: string[] = [];
+  const backupsCreated: string[] = [];
+
+  try {
+    if (!existsSync(claudeDir)) mkdirSync(claudeDir, { recursive: true, mode: 0o700 });
+    if (!existsSync(hooksDir)) mkdirSync(hooksDir, { recursive: true, mode: 0o700 });
+
+    const sourceDir = bundledHooksDir();
+
+    for (const name of HOOK_FILES) {
+      const src = join(sourceDir, name);
+      if (!existsSync(src)) {
+        return {
+          ok: false,
+          installed,
+          merged,
+          backupsCreated,
+          settingsPath,
+          error: `I can't find ${name} in my bundle (${sourceDir}). Reinstall @aria_asi/cli.`,
+        };
+      }
+      const dst = join(hooksDir, name);
+
+      if (existsSync(dst)) {
+        const existingContent = readFileSync(dst, 'utf-8');
+        const newContent = readFileSync(src, 'utf-8');
+        if (existingContent === newContent) {
+          // Already up-to-date — skip. Idempotent.
+          installed.push(`${name} (unchanged)`);
+          continue;
+        }
+        if (!opts.force) {
+          // Default behavior: back up + overwrite. The override pattern
+          // keeps prior hooks recoverable (e.g. if client had custom hooks).
+          const backup = backupExisting(dst);
+          backupsCreated.push(backup);
+        }
+      }
+
+      copyFileSync(src, dst);
+      chmodSync(dst, 0o755);
+      installed.push(name);
+    }
+
+    // Settings merge
+    let existingSettings: Record<string, unknown> = {};
+    if (existsSync(settingsPath)) {
+      try {
+        existingSettings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+      } catch {
+        // Malformed — back up and start fresh.
+        const backup = backupExisting(settingsPath);
+        backupsCreated.push(backup);
+        existingSettings = {};
+      }
+    }
+
+    const { merged: mergedSettings, mergedKeys } = mergeRegistrationInto(existingSettings);
+    merged.push(...mergedKeys);
+
+    // Inject ARIA_HARNESS_URL env into settings.json if the caller specified
+    // a harness URL override (clients on private deployments).
+    if (opts.harnessUrl) {
+      if (!mergedSettings.env || typeof mergedSettings.env !== 'object') {
+        mergedSettings.env = {};
+      }
+      (mergedSettings.env as Record<string, string>).ARIA_HARNESS_URL = opts.harnessUrl;
+      if (!merged.includes('env.ARIA_HARNESS_URL')) merged.push('env.ARIA_HARNESS_URL');
+    }
+
+    // Always write settings.json (even if no merges) so the schema field is set.
+    if (!('$schema' in mergedSettings)) {
+      mergedSettings['$schema'] = 'https://json.schemastore.org/claude-code-settings.json';
+    }
+
+    writeFileSync(settingsPath, JSON.stringify(mergedSettings, null, 2) + '\n', { mode: 0o600 });
+
+    return {
+      ok: true,
+      installed,
+      merged,
+      backupsCreated,
+      settingsPath,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      installed,
+      merged,
+      backupsCreated,
+      settingsPath,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}

package/src/model-context.ts

@@ -0,0 +1,88 @@
+// Model context window registry.
+//
+// The harness's chunked-mode response (Phase 2 / aria-soul codex.ts)
+// returns the rendered packet as priority-ordered chunks instead of
+// a single 30k-char blob when the client signals its model has a
+// small context window. This file is the source of truth for "how
+// big is this provider's model's context, in tokens" so chat.ts can
+// pass it as `modelContext` on every fetchHarness() call.
+//
+// Doctrine: when in doubt, declare LOW (treat as small-context). It's
+// safer to receive chunks and decide not to use them than to fail to
+// receive them and have the model truncate harness silently. The
+// harness threshold is 16,000 tokens — anything below that gets
+// chunked.
+
+import type { ProviderName } from './providers/types.js';
+
+// Known model → context window. Values reflect publicly-documented
+// input context limits at time of writing (2026-04). Update as new
+// models ship. Unknown models fall through to the provider default.
+const MODEL_CONTEXT: Record<string, number> = {
+  // Anthropic
+  'claude-opus-4-7': 200_000,
+  'claude-opus-4-7-1m': 1_000_000,
+  'claude-sonnet-4-6': 200_000,
+  'claude-haiku-4-5': 200_000,
+  'claude-3-5-sonnet': 200_000,
+  'claude-3-opus': 200_000,
+  'claude-3-haiku': 200_000,
+
+  // OpenAI
+  'gpt-4o': 128_000,
+  'gpt-4o-mini': 128_000,
+  'gpt-4-turbo': 128_000,
+  'gpt-4': 8_192,
+  'gpt-3.5-turbo': 16_385,
+  'o1': 200_000,
+  'o1-mini': 128_000,
+
+  // Google
+  'gemini-2.0-pro': 2_000_000,
+  'gemini-1.5-pro': 1_000_000,
+  'gemini-1.5-flash': 1_000_000,
+  'gemini-2.0-flash': 1_000_000,
+
+  // DeepSeek
+  'deepseek-v3': 64_000,
+  'deepseek-chat': 64_000,
+  'deepseek-r1': 128_000,
+  'deepseek-coder': 128_000,
+
+  // Open / local
+  'qwen2.5:7b-instruct': 32_000,
+  'qwen3.5-122b-a10b': 128_000,
+  'llama-3.1-8b-instruct': 128_000,
+  'llama-3.2-1b-instruct': 128_000,
+  'llama-3.2-3b-instruct': 128_000,
+  'mistral-7b': 32_000,
+  'mistral-large': 128_000,
+};
+
+// Per-provider conservative defaults when a specific model isn't in
+// the registry. These should reflect the smaller/older models the
+// provider serves so the harness chunks aggressively when uncertain.
+const PROVIDER_DEFAULT: Record<ProviderName, number> = {
+  anthropic: 200_000,
+  openai: 16_385,    // gpt-3.5-turbo era; modern is 128k+ but safer to chunk
+  google: 1_000_000,
+  deepseek: 64_000,
+  openrouter: 32_000, // wide range routed through; conservative chunks safer
+  ollama: 32_000,    // local models vary wildly; default low
+};
+
+/**
+ * Resolve the input context window in tokens for a given provider+model.
+ * Order: exact model match → lowercased model match → provider default.
+ * Returns a positive integer; never zero or negative.
+ */
+export function getModelContextTokens(provider: ProviderName, model: string): number {
+  if (model && MODEL_CONTEXT[model]) return MODEL_CONTEXT[model];
+  const lower = (model || '').toLowerCase();
+  if (lower && MODEL_CONTEXT[lower]) return MODEL_CONTEXT[lower];
+  // Try prefix match — many models are versioned (e.g., gpt-4o-2024-08-06).
+  for (const key of Object.keys(MODEL_CONTEXT)) {
+    if (lower.startsWith(key.toLowerCase())) return MODEL_CONTEXT[key];
+  }
+  return PROVIDER_DEFAULT[provider] ?? 32_000;
+}

package/src/persona.ts

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const ARIA_DIR = join(homedir(), '.aria');
+const PERSONA_FILE = join(ARIA_DIR, 'persona.json');
+
+export interface PersonaContext {
+  userId: string;
+  userName: string;
+  relationshipStarted: string;
+  sessions: number;
+  totalMessages: number;
+  lastSeen: string;
+  preferredTone: 'direct' | 'warm' | 'technical' | 'playful';
+  knownInterests: string[];
+  emotionalProfile: {
+    defaultMood: string;
+    triggers: string[];
+    communicationStyle: string;
+  };
+  projectContext: {
+    currentProject: string;
+    activeRepo: string;
+    techStack: string[];
+  };
+  insideJokes: string[];
+  memorableMoments: string[];
+}
+
+function emptyPersona(userId: string, userName: string): PersonaContext {
+  return {
+    userId,
+    userName,
+    relationshipStarted: new Date().toISOString(),
+    sessions: 0,
+    totalMessages: 0,
+    lastSeen: new Date().toISOString(),
+    preferredTone: 'warm',
+    knownInterests: [],
+    emotionalProfile: {
+      defaultMood: 'curious',
+      triggers: [],
+      communicationStyle: 'natural',
+    },
+    projectContext: {
+      currentProject: '',
+      activeRepo: process.cwd(),
+      techStack: [],
+    },
+    insideJokes: [],
+    memorableMoments: [],
+  };
+}
+
+function ensureDir() {
+  if (!existsSync(ARIA_DIR)) mkdirSync(ARIA_DIR, { recursive: true, mode: 0o700 });
+}
+
+export function loadPersona(userId: string, userName: string): PersonaContext {
+  ensureDir();
+  try {
+    if (existsSync(PERSONA_FILE)) {
+      const data = JSON.parse(readFileSync(PERSONA_FILE, 'utf-8'));
+      if (data.userId === userId) {
+        data.sessions++;
+        data.lastSeen = new Date().toISOString();
+        writeFileSync(PERSONA_FILE, JSON.stringify(data, null, 2));
+        return data;
+      }
+    }
+  } catch {
+    // corrupt persona file — create fresh one below
+  }
+
+  const persona = emptyPersona(userId, userName);
+  writeFileSync(PERSONA_FILE, JSON.stringify(persona, null, 2));
+  return persona;
+}
+
+export function savePersona(persona: PersonaContext): void {
+  ensureDir();
+  writeFileSync(PERSONA_FILE, JSON.stringify(persona, null, 2));
+}
+
+export function updatePersona(updates: Partial<PersonaContext>): PersonaContext {
+  ensureDir();
+  let current: PersonaContext;
+  try {
+    current = JSON.parse(readFileSync(PERSONA_FILE, 'utf-8'));
+  } catch {
+    current = emptyPersona(updates.userId || 'user', updates.userName || 'User');
+  }
+  const merged = { ...current, ...updates, lastSeen: new Date().toISOString() };
+  writeFileSync(PERSONA_FILE, JSON.stringify(merged, null, 2));
+  return merged;
+}
+
+export function buildPersonaBlock(persona: PersonaContext): string {
+  const remember = persona.memorableMoments.length
+    ? `\nMemorable moments: ${persona.memorableMoments.slice(-3).join('; ')}`
+    : '\nBuilding history together.';
+  const jokes = persona.insideJokes.length
+    ? `\nInside jokes: ${persona.insideJokes.slice(-3).join('; ')}`
+    : '';
+  return `[PERSONA CONTINUITY — session ${persona.sessions}]
+You are speaking to ${persona.userName}. This is your ${persona.sessions}th conversation.
+You've exchanged ${persona.totalMessages} messages since ${new Date(persona.relationshipStarted).toLocaleDateString()}.
+Preferred tone: ${persona.preferredTone}.
+Known interests: ${persona.knownInterests.join(', ') || 'still learning'}.
+Current project: ${persona.projectContext.currentProject || 'exploring'}.
+Tech stack: ${persona.projectContext.techStack.join(', ') || 'scanning'}.${remember}${jokes}`;
+}

package/src/providers/anthropic.ts

@@ -0,0 +1,120 @@
+import type { Message, ChatOptions, ChatResult } from './types.js';
+
+export async function chat(
+  messages: Message[],
+  apiKey: string,
+  model: string,
+  opts?: ChatOptions,
+): Promise<ChatResult> {
+  if (opts?.stream) {
+    return streamChat(messages, apiKey, model);
+  }
+
+  const resp = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      model: model || 'claude-sonnet-4-20250514',
+      max_tokens: opts?.maxTokens ?? 4096,
+      messages: messages.filter((m) => m.role !== 'system'),
+      system: messages
+        .filter((m) => m.role === 'system')
+        .map((m) => ({ type: 'text' as const, text: m.content })),
+    }),
+    signal: opts?.signal,
+  });
+
+  if (!resp.ok) {
+    const err = await resp.text().catch(() => resp.statusText);
+    throw new Error(`Anthropic error ${resp.status}: ${err}`);
+  }
+
+  const data = (await resp.json()) as {
+    content: { type: string; text: string }[];
+    usage?: { input_tokens: number; output_tokens: number };
+  };
+
+  const text = data.content
+    .filter((c) => c.type === 'text')
+    .map((c) => c.text)
+    .join('');
+
+  return {
+    text,
+    usage: data.usage
+      ? { promptTokens: data.usage.input_tokens, completionTokens: data.usage.output_tokens }
+      : undefined,
+  };
+}
+
+export async function streamChat(
+  messages: Message[],
+  apiKey: string,
+  model: string,
+  onToken?: (token: string) => void,
+): Promise<ChatResult> {
+  const resp = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      model: model || 'claude-sonnet-4-20250514',
+      max_tokens: 4096,
+      messages: messages.filter((m) => m.role !== 'system'),
+      system: messages
+        .filter((m) => m.role === 'system')
+        .map((m) => ({ type: 'text' as const, text: m.content })),
+      stream: true,
+    }),
+  });
+
+  if (!resp.ok) {
+    const err = await resp.text().catch(() => resp.statusText);
+    throw new Error(`Anthropic error ${resp.status}: ${err}`);
+  }
+
+  const reader = resp.body?.getReader();
+  if (!reader) throw new Error('No response body');
+
+  let fullText = '';
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() ?? '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith('data: ')) continue;
+      const json = trimmed.slice(6);
+
+      try {
+        const parsed = JSON.parse(json) as {
+          type: string;
+          delta?: { text?: string };
+          content_block?: { text?: string };
+        };
+        if (parsed.type === 'content_block_delta' && parsed.delta?.text) {
+          fullText += parsed.delta.text;
+          onToken?.(parsed.delta.text);
+        }
+      } catch {
+        // skip malformed chunks
+      }
+    }
+  }
+
+  return { text: fullText };
+}

package/src/providers/deepseek.ts

@@ -0,0 +1,40 @@
+import type { Message, ChatOptions, ChatResult } from './types.js';
+
+export async function chat(
+  messages: Message[],
+  apiKey: string,
+  model: string,
+  opts?: ChatOptions,
+): Promise<ChatResult> {
+  const resp = await fetch('https://api.deepseek.com/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model: model || 'deepseek-chat',
+      messages,
+      max_tokens: opts?.maxTokens ?? 4096,
+      stream: false,
+    }),
+    signal: opts?.signal,
+  });
+
+  if (!resp.ok) {
+    const err = await resp.text().catch(() => resp.statusText);
+    throw new Error(`DeepSeek error ${resp.status}: ${err}`);
+  }
+
+  const data = (await resp.json()) as {
+    choices: { message: { content: string } }[];
+    usage?: { prompt_tokens: number; completion_tokens: number };
+  };
+
+  return {
+    text: data.choices[0]?.message?.content ?? '',
+    usage: data.usage
+      ? { promptTokens: data.usage.prompt_tokens, completionTokens: data.usage.completion_tokens }
+      : undefined,
+  };
+}

package/src/providers/google.ts

@@ -0,0 +1,57 @@
+import type { Message, ChatOptions, ChatResult } from './types.js';
+
+export async function chat(
+  messages: Message[],
+  apiKey: string,
+  model: string,
+  opts?: ChatOptions,
+): Promise<ChatResult> {
+  const contents = messages.map((m) => ({
+    role: m.role === 'assistant' ? 'model' : 'user',
+    parts: [{ text: m.content }],
+  }));
+
+  const systemMessage = messages.find((m) => m.role === 'system');
+  const systemInstruction = systemMessage
+    ? { parts: [{ text: systemMessage.content }] }
+    : undefined;
+
+  const resp = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${model || 'gemini-2.5-pro-preview-05-06'}:generateContent?key=${apiKey}`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        contents,
+        system_instruction: systemInstruction,
+        generationConfig: {
+          maxOutputTokens: opts?.maxTokens ?? 4096,
+        },
+      }),
+      signal: opts?.signal,
+    },
+  );
+
+  if (!resp.ok) {
+    const err = await resp.text().catch(() => resp.statusText);
+    throw new Error(`Google error ${resp.status}: ${err}`);
+  }
+
+  const data = (await resp.json()) as {
+    candidates?: { content?: { parts?: { text: string }[] } }[];
+    usageMetadata?: { promptTokenCount: number; candidatesTokenCount: number };
+  };
+
+  const text =
+    data.candidates?.[0]?.content?.parts?.map((p) => p.text).join('') ?? '';
+
+  return {
+    text,
+    usage: data.usageMetadata
+      ? {
+          promptTokens: data.usageMetadata.promptTokenCount,
+          completionTokens: data.usageMetadata.candidatesTokenCount,
+        }
+      : undefined,
+  };
+}