@monoes/monograph 1.2.1 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monograph",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "type": "module",
   "description": "Native TypeScript code intelligence engine for monomind",
   "main": "dist/src/index.js",

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/cli/skill-gen.ts

@@ -245,6 +245,9 @@ function renderSkillMarkdown(
   lines.push('---');
   lines.push(`name: ${toKebabName(label)}`);
   lines.push(`description: "Skill for the ${label} community. ${members.length} symbols."`);
+  lines.push(`type: Code Community`);
+  lines.push(`tags: [monograph, code-community]`);
+  lines.push(`timestamp: ${new Date().toISOString()}`);
   lines.push('---');
   lines.push('');
 

package/src/graph/node-search.ts

@@ -1,3 +1,4 @@
+import Database from 'better-sqlite3';
 import type { MonographNode, NodeLabel } from '../types.js';
 import type { MonographDb } from '../storage/db.js';
 
@@ -55,13 +56,13 @@ function rowToNode(r: {
 // so the same query shape reuses the compiled statement across calls.
 
 // WeakMap ensures the cache is garbage-collected when the DB object is released.
-const stmtCache = new WeakMap<object, Map<string, ReturnType<MonographDb['prepare']>>>();
+const stmtCache = new WeakMap<object, Map<string, Database.Statement>>();
 
 function getCachedStmt(
   db: MonographDb,
   key: string,
   buildSql: () => string,
-): ReturnType<MonographDb['prepare']> {
+): Database.Statement {
   let dbCache = stmtCache.get(db);
   if (!dbCache) {
     dbCache = new Map();

package/src/graph/pagerank.ts

@@ -1,3 +1,4 @@
+import Database from 'better-sqlite3';
 import type { MonographDb } from '../storage/db.js';
 
 export interface PageRankOptions {
@@ -13,8 +14,8 @@ export interface PageRankOptions {
 // Per-DB statement cache — avoids recompiling SQL on every pageRank() call.
 // ---------------------------------------------------------------------------
 interface StmtCache {
-  selectNodes: ReturnType<MonographDb['prepare']>;
-  selectEdges: ReturnType<MonographDb['prepare']>;
+  selectNodes: Database.Statement;
+  selectEdges: Database.Statement;
 }
 
 const _stmtCache = new Map<string, StmtCache>();

package/src/graph/subgraph.ts

@@ -1,3 +1,4 @@
+import Database from 'better-sqlite3';
 import type { MonographNode, MonographEdge } from '../types.js';
 import type { MonographDb } from '../storage/db.js';
 
@@ -66,7 +67,7 @@ export function extractInducedSubgraph(db: MonographDb, nodeIds: string[]): Indu
   const stmts = getStmtCaches(db);
 
   // Chunk helper — caches prepared statements by chunk size to avoid re-prepare per call.
-  function queryChunked<T>(ids: string[], chunkSize: number, stmtCache: Map<number, ReturnType<MonographDb['prepare']>>, sql: (ph: string) => string): T[] {
+  function queryChunked<T>(ids: string[], chunkSize: number, stmtCache: Map<number, Database.Statement>, sql: (ph: string) => string): T[] {
     const results: T[] = [];
     for (let i = 0; i < ids.length; i += chunkSize) {
       const chunk = ids.slice(i, i + chunkSize);

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/wiki-generator.ts

@@ -145,22 +145,18 @@ 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
+  // 7. Persist to DB — prepend OKF frontmatter if not already present
+  if (!content.startsWith('---')) {
+    const safeLabel = label.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    content = `---\ntype: Code Community Wiki\ntitle: "${safeLabel}"\ntags: [monograph, wiki]\ntimestamp: ${new Date().toISOString()}\n---\n\n${content}`;
+  }
   upsertWikiPage(db, communityIdStr, content);
 
   return content;