@monoes/monograph 1.2.2 → 1.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monograph",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "type": "module",
   "description": "Native TypeScript code intelligence engine for monomind",
   "main": "dist/src/index.js",
@@ -57,4 +57,4 @@
     "typescript": "^5.3.0",
     "vitest": "^4.1.4"
   }
-}
+}

package/src/claude-cli.ts

@@ -0,0 +1,59 @@
+/**
+ * Thin wrapper around `claude --print` for LLM calls inside monograph.
+ * Reuses Claude Code's existing auth — no ANTHROPIC_API_KEY needed.
+ */
+import { spawn, execSync } from 'child_process';
+
+const DEFAULT_TIMEOUT_MS = 60_000;
+let _available: boolean | null = null;
+
+export function isClaudeCliAvailable(): boolean {
+  if (_available !== null) return _available;
+  try {
+    execSync('claude --version', { encoding: 'utf-8', stdio: 'pipe', timeout: 5000, windowsHide: true });
+    _available = true;
+  } catch {
+    _available = false;
+  }
+  return _available;
+}
+
+export function claudeCliCall(prompt: string, timeoutMs = DEFAULT_TIMEOUT_MS): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(
+      'claude',
+      ['--print', '--model', 'haiku', '--strict-mcp-config', '--no-session-persistence', '--', prompt],
+      { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true },
+    );
+
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      try { child.kill('SIGTERM'); } catch { /* ignore */ }
+      setTimeout(() => { try { child.kill('SIGKILL'); } catch { /* ignore */ } }, 3000);
+      reject(new Error(`claude --print timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    child.stdout.on('data', (d: Buffer) => { stdout += d.toString(); });
+    child.stderr.on('data', (d: Buffer) => { stderr += d.toString(); });
+
+    child.on('close', (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (code === 0) resolve(stdout.trim());
+      else reject(new Error(stderr.trim() || `claude exited with code ${code}`));
+    });
+
+    child.on('error', (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}

package/src/mcp-tools/wiki-build.ts

@@ -25,11 +25,6 @@ export async function runWikiBuildTool(
   db: MonographDb,
   input: WikiBuildToolInput,
 ): Promise<WikiBuildToolResult> {
-  const apiKey = process.env['ANTHROPIC_API_KEY'];
-  if (!apiKey && !input.llmClient) {
-    return { error: 'ANTHROPIC_API_KEY not set' };
-  }
-
   const opts: GenerateAllWikiPagesOptions = {
     force: input.force ?? false,
     model: input.model,

package/src/pipeline/phases/llm-extract.ts

@@ -37,25 +37,11 @@ interface Triple {
   edge: string;
 }
 
-async function callClaude(content: string, apiKey: string): Promise<Triple[] | null> {
+async function callClaude(content: string): Promise<Triple[] | null> {
   try {
-    const res = await fetch('https://api.anthropic.com/v1/messages', {
-      method: 'POST',
-      headers: {
-        'x-api-key': apiKey,
-        'anthropic-version': '2023-06-01',
-        'content-type': 'application/json',
-      },
-      body: JSON.stringify({
-        model: 'claude-haiku-4-5-20251001',
-        max_tokens: 512,
-        system: SYSTEM_PROMPT,
-        messages: [{ role: 'user', content: content.slice(0, 1500) }],
-      }),
-    });
-    if (!res.ok) return null;
-    const data = await res.json() as { content: Array<{ text: string }> };
-    const text = data.content[0]?.text ?? '[]';
+    const { claudeCliCall } = await import('../../claude-cli.js');
+    const prompt = `${SYSTEM_PROMPT}\n\n${content.slice(0, 1500)}`;
+    const text = await claudeCliCall(prompt, 30_000);
     const parsed = JSON.parse(text.match(/\[[\s\S]*\]/)?.[0] ?? '[]');
     return Array.isArray(parsed) ? parsed as Triple[] : null;
   } catch {
@@ -68,10 +54,14 @@ export const llmExtractPhase: PipelinePhase<LlmExtractOutput> = {
   deps: ['docs-parse', 'pdf-parse'],
 
   async execute(ctx: PipelineContext) {
-    const apiKey = process.env.ANTHROPIC_API_KEY;
     const maxSections = ctx.options.llmMaxSections;
 
-    if (!apiKey || maxSections <= 0 || ctx.options.codeOnly) {
+    if (maxSections <= 0 || ctx.options.codeOnly) {
+      return { triplesExtracted: 0, sectionsProcessed: 0 };
+    }
+
+    const { isClaudeCliAvailable } = await import('../../claude-cli.js');
+    if (!isClaudeCliAvailable()) {
       return { triplesExtracted: 0, sectionsProcessed: 0 };
     }
 
@@ -107,7 +97,6 @@ export const llmExtractPhase: PipelinePhase<LlmExtractOutput> = {
 
       const triples = await callClaude(
         `Section: "${section.name}"\n\n${content}`,
-        apiKey,
       );
       if (!triples || triples.length === 0) continue;
 

package/src/wiki/providers.ts

@@ -49,39 +49,13 @@ export async function callLLM(prompt: string, config: LLMConfig): Promise<LLMRes
 
 async function callAnthropic(
   prompt: string,
-  config: LLMConfig,
-  signal: AbortSignal,
+  _config: LLMConfig,
+  _signal: AbortSignal,
 ): Promise<LLMResponse> {
-  const apiKey = config.apiKey ?? process.env['ANTHROPIC_API_KEY'];
-  const response = await fetch('https://api.anthropic.com/v1/messages', {
-    method: 'POST',
-    signal,
-    headers: {
-      'x-api-key': apiKey ?? '',
-      'anthropic-version': '2023-06-01',
-      'content-type': 'application/json',
-    },
-    body: JSON.stringify({
-      model: config.model ?? 'claude-3-haiku-20240307',
-      max_tokens: config.maxTokens ?? 2048,
-      messages: [{ role: 'user', content: prompt }],
-    }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`LLM provider anthropic error: ${response.status} ${response.statusText}`);
-  }
-
-  const data = await response.json() as {
-    content: Array<{ text: string }>;
-    usage: { input_tokens: number; output_tokens: number };
-  };
-
-  return {
-    text: data.content[0].text,
-    inputTokens: data.usage.input_tokens,
-    outputTokens: data.usage.output_tokens,
-  };
+  // Route through Claude Code CLI — reuses host auth, no API key needed.
+  const { claudeCliCall } = await import('../claude-cli.js');
+  const text = await claudeCliCall(prompt);
+  return { text };
 }
 
 async function callOpenAI(

package/src/wiki/wiki-generator.ts

@@ -145,19 +145,11 @@ export async function generateWikiPage(
     const result = await callLLM(prompt, options.llmConfig);
     content = result.text;
   } else {
-    const apiKey = options?.apiKey ?? process.env['ANTHROPIC_API_KEY'];
-    if (!apiKey) {
-      throw new Error('ANTHROPIC_API_KEY not set');
+    const { claudeCliCall, isClaudeCliAvailable } = await import('../claude-cli.js');
+    if (!isClaudeCliAvailable()) {
+      throw new Error('Claude Code CLI not found. Install with: npm install -g @anthropic-ai/claude-code');
     }
-    const { default: Anthropic } = await import('@anthropic-ai/sdk');
-    const client = new Anthropic({ apiKey });
-    const msg = await client.messages.create({
-      model: options?.model ?? 'claude-haiku-4-5-20251001',
-      max_tokens: 1024,
-      messages: [{ role: 'user', content: prompt }],
-    });
-    const block = msg.content[0];
-    content = (block?.type === 'text') ? block.text : '';
+    content = await claudeCliCall(prompt);
   }
 
   // 7. Persist to DB — prepend OKF frontmatter if not already present