@aria_asi/cli 0.2.0

package/src/providers/ollama.ts

@@ -0,0 +1,43 @@
+import type { Message, ChatOptions, ChatResult } from './types.js';
+
+export async function chat(
+  messages: Message[],
+  _apiKey: string,
+  model: string,
+  opts?: ChatOptions,
+): Promise<ChatResult> {
+  const baseUrl = process.env.OLLAMA_HOST || 'http://localhost:11434';
+
+  const resp = await fetch(`${baseUrl}/api/chat`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      model: model || 'llama3',
+      messages,
+      stream: false,
+      options: {
+        num_predict: opts?.maxTokens ?? 4096,
+      },
+    }),
+    signal: opts?.signal,
+  });
+
+  if (!resp.ok) {
+    const err = await resp.text().catch(() => resp.statusText);
+    throw new Error(`Ollama error ${resp.status}: ${err}`);
+  }
+
+  const data = (await resp.json()) as {
+    message?: { content: string };
+    eval_count?: number;
+    prompt_eval_count?: number;
+  };
+
+  return {
+    text: data.message?.content ?? '',
+    usage:
+      data.prompt_eval_count !== undefined
+        ? { promptTokens: data.prompt_eval_count, completionTokens: data.eval_count ?? 0 }
+        : undefined,
+  };
+}

package/src/providers/openai.ts

@@ -0,0 +1,108 @@
+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.openai.com/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model: model || 'gpt-4o',
+      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(`OpenAI 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,
+  };
+}
+
+export async function streamChat(
+  messages: Message[],
+  apiKey: string,
+  model: string,
+  onToken?: (token: string) => void,
+): Promise<ChatResult> {
+  const resp = await fetch('https://api.openai.com/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model: model || 'gpt-4o',
+      messages,
+      max_tokens: 4096,
+      stream: true,
+    }),
+  });
+
+  if (!resp.ok) {
+    const err = await resp.text().catch(() => resp.statusText);
+    throw new Error(`OpenAI 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);
+      if (json === '[DONE]') continue;
+
+      try {
+        const parsed = JSON.parse(json) as {
+          choices?: { delta?: { content?: string } }[];
+        };
+        const token = parsed.choices?.[0]?.delta?.content;
+        if (token) {
+          fullText += token;
+          onToken?.(token);
+        }
+      } catch {
+        // skip malformed chunks
+      }
+    }
+  }
+
+  return { text: fullText };
+}

package/src/providers/openrouter.ts

@@ -0,0 +1,42 @@
+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://openrouter.ai/api/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${apiKey}`,
+      'HTTP-Referer': 'http://localhost',
+      'X-Title': 'Aria Smart CLI',
+    },
+    body: JSON.stringify({
+      model: model || 'openai/gpt-4o',
+      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(`OpenRouter 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/types.ts

@@ -0,0 +1,35 @@
+export interface Message {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+export interface ChatOptions {
+  stream?: boolean;
+  maxTokens?: number;
+  signal?: AbortSignal;
+}
+
+export interface ChatResult {
+  text: string;
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+  };
+}
+
+export type ProviderName = 'openai' | 'anthropic' | 'google' | 'deepseek' | 'openrouter' | 'ollama';
+
+export type ChatFn = (
+  messages: Message[],
+  apiKey: string,
+  model: string,
+  opts?: ChatOptions,
+) => Promise<ChatResult>;
+
+export type StreamChatFn = (
+  messages: Message[],
+  apiKey: string,
+  model: string,
+  onToken: (token: string) => void,
+  opts?: ChatOptions,
+) => Promise<ChatResult>;

package/src/setup-wizard.ts

@@ -0,0 +1,177 @@
+// Thin-loop onboarding — server-driven deep conversation.
+//
+// Replaces the prior 200-line hardcoded Q&A wizard. The CLI is now a
+// pure render loop calling /api/onboarding/converse on aria-soul; the
+// server holds the topic state machine, depth tracking, and templated
+// (eventually Aria-voiced) prompts. Every configWrite the server emits
+// is applied locally here — that keeps integration provisioning
+// (codebase scan, persona update, config set) on the client where it
+// belongs without baking the conversation flow into the CLI.
+//
+// Direction set 2026-04-26 (Hamza): "onboarding is not a Q&A wizard.
+// It's a deep conversation with Aria directly, where Aria and the user
+// co-direct depth." See HARNESS_RELEASE_PLAN.md §"Onboarding refactor"
+// and apps/arias-soul/api/onboarding/converse.ts for the server side.
+
+import { createInterface } from 'readline';
+import { randomBytes } from 'crypto';
+import { loadConfig, updateConfig, type AriaConfig, type LinkedRepo } from './config.js';
+import { scanCodebase, schemaImageToText } from './codebase-scanner.js';
+import { updatePersona } from './persona.js';
+
+const HARNESS_URL = process.env.ARIA_HARNESS_URL || 'http://192.168.4.25:30080';
+const HARNESS_TOKEN = process.env.ARIA_HARNESS_TOKEN || '';
+
+type ConfigWrite =
+  | { kind: 'persona_update'; updates: Record<string, unknown> }
+  | { kind: 'config_set'; path: string[]; value: unknown }
+  | { kind: 'codebase_scan'; cwd: string }
+  | { kind: 'note'; text: string };
+
+interface DepthOption {
+  label: string;
+  signal: string;
+  hint?: string;
+}
+
+interface ConverseResponse {
+  ok: boolean;
+  sessionId: string;
+  topic: 'identity' | 'codebase' | 'persona' | 'done';
+  ariaPrompt: string;
+  depthOptions: DepthOption[];
+  freeTextAllowed: boolean;
+  configWrites?: ConfigWrite[];
+  isComplete: boolean;
+  progressPct: number;
+  error?: string;
+}
+
+export async function runSetupWizard(): Promise<void> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q: string): Promise<string> =>
+    new Promise((resolve) => rl.question(q, (a) => resolve(a)));
+
+  const sessionId = `onboard_${Date.now()}_${randomBytes(4).toString('hex')}`;
+  let userMessage: string | undefined;
+  let action: 'start' | 'answer' = 'start';
+
+  console.log('\n💬 Aria: starting onboarding…\n');
+
+  try {
+    while (true) {
+      const resp = await callConverse({ sessionId, action, userMessage });
+      if (!resp.ok) {
+        console.error(`\n❌ Onboarding error: ${resp.error || 'unknown'}`);
+        return;
+      }
+
+      console.log(`\n💬 Aria: ${resp.ariaPrompt}`);
+
+      if (resp.configWrites?.length) {
+        await applyConfigWrites(resp.configWrites);
+      }
+
+      if (resp.isComplete) break;
+
+      if (resp.depthOptions.length) {
+        const chips = resp.depthOptions.map((o) => `[${o.label}]`).join(' ');
+        console.log(`     options: ${chips}${resp.freeTextAllowed ? '  (or type your own)' : ''}`);
+      }
+
+      userMessage = (await ask('> ')).trim();
+      action = 'answer';
+      if (!userMessage) userMessage = resp.depthOptions[0]?.signal ?? 'next';
+    }
+
+    console.log('\n✅ Setup complete. Run `aria status` anytime.\n');
+  } finally {
+    rl.close();
+  }
+}
+
+async function callConverse(body: {
+  sessionId: string;
+  action: 'start' | 'answer';
+  userMessage?: string;
+}): Promise<ConverseResponse> {
+  try {
+    const res = await fetch(`${HARNESS_URL}/api/onboarding/converse`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(HARNESS_TOKEN ? { Authorization: `Bearer ${HARNESS_TOKEN}` } : {}),
+      },
+      body: JSON.stringify(body),
+    });
+    return (await res.json()) as ConverseResponse;
+  } catch (err) {
+    return {
+      ok: false,
+      sessionId: body.sessionId,
+      topic: 'identity',
+      ariaPrompt: '',
+      depthOptions: [],
+      freeTextAllowed: false,
+      isComplete: false,
+      progressPct: 0,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+async function applyConfigWrites(writes: ConfigWrite[]): Promise<void> {
+  for (const w of writes) {
+    try {
+      if (w.kind === 'persona_update') {
+        updatePersona(w.updates as Parameters<typeof updatePersona>[0]);
+      } else if (w.kind === 'config_set') {
+        const patch = pathToPatch(w.path, w.value);
+        updateConfig(patch);
+      } else if (w.kind === 'codebase_scan') {
+        const cwd = w.cwd === '__CLI_CWD__' ? process.cwd() : w.cwd;
+        const image = await scanCodebase(cwd);
+        const text = schemaImageToText(image);
+        const config = loadConfig();
+        updateConfig({
+          schemaImages: { ...config.schemaImages, [image.projectName]: text },
+          repositories: [
+            ...config.repositories.filter((r) => r.path !== cwd),
+            {
+              path: cwd,
+              name: image.projectName,
+              scanHash: '',
+              lastScan: new Date().toISOString(),
+            } as LinkedRepo,
+          ],
+        });
+        console.log(
+          `     scanned: ${image.language}${image.framework && image.framework !== image.language ? `, ${image.framework}` : ''}` +
+            `${image.orm ? `, ${image.orm}` : ''}${image.database ? ` with ${image.database}` : ''}` +
+            ` — ${image.fileCount} files`,
+        );
+      } else if (w.kind === 'note') {
+        console.log(`     📝 ${w.text}`);
+      }
+    } catch (err) {
+      console.warn(`     ⚠ configWrite '${w.kind}' failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}
+
+function pathToPatch(path: string[], value: unknown): Partial<AriaConfig> {
+  if (path.length === 1) return { [path[0]]: value } as Partial<AriaConfig>;
+  // Nested path → shallow merge under top-level key.
+  const top = path[0] as keyof AriaConfig;
+  const rest = path.slice(1);
+  const config = loadConfig();
+  const current = (config[top] ?? {}) as Record<string, unknown>;
+  const cursor: Record<string, unknown> = { ...current };
+  let pointer: Record<string, unknown> = cursor;
+  for (let i = 0; i < rest.length - 1; i++) {
+    pointer[rest[i]] = { ...((pointer[rest[i]] as Record<string, unknown>) ?? {}) };
+    pointer = pointer[rest[i]] as Record<string, unknown>;
+  }
+  pointer[rest[rest.length - 1]] = value;
+  return { [top]: cursor } as Partial<AriaConfig>;
+}

package/src/types.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared types for harness-client and cognition log.
+ */
+
+export interface AuthConfig {
+  /** Token from license file or env var */
+  harnessToken?: string;
+  /** License JWT identifier */
+  jti?: string;
+  /** License tier (e.g. 'standard', 'pro') */
+  tier?: string;
+  /** License expiry unix timestamp */
+  exp?: number;
+  /** License issued-at unix timestamp */
+  iat?: number;
+  /** License subject (userId) */
+  sub?: string;
+}
+
+export interface HarnessResponse<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}
+
+export interface HarnessGateDecision {
+  gate: string;
+  passed: boolean;
+  reason?: string;
+  score?: number;
+  metadata?: Record<string, unknown>;
+}