@var-ia/cli 0.1.0 → 0.3.0

package/src/commands/watch.ts

@@ -7,8 +7,9 @@ const POLL_INTERVAL_MS = 60_000;
 export async function runWatch(
   pageTitle: string,
   section?: string,
+  apiUrl?: string,
 ): Promise<void> {
-  const client = new MediaWikiClient();
+  const client = new MediaWikiClient(apiUrl ? { apiUrl } : undefined);
   console.log(`Watching "${pageTitle}"${section ? ` section="${section}"` : ""}`);
   console.log(`Polling every ${POLL_INTERVAL_MS / 1000}s. Press Ctrl+C to stop.\n`);
 

package/src/index.ts

@@ -1,25 +1,34 @@
 import { runAnalyze } from "./commands/analyze.js";
 import { runClaim } from "./commands/claim.js";
+import { runEval } from "./commands/eval.js";
 import { runExport } from "./commands/export.js";
 import { runWatch } from "./commands/watch.js";
+import type { ModelConfig } from "@var-ia/interpreter";
 
 const HELP = `
 wikihistory — Wikipedia edit history analysis
 
 Usage:
-  wikihistory analyze <page> [--depth brief|detailed|forensic] [--from <revId>] [--to <revId>] [--cache]
-  wikihistory claim <page> --text "<claim text>" [--cache]
-  wikihistory export <page> --format json|csv
+  wikihistory analyze <page> [--depth brief|detailed|forensic] [--from <revId>] [--to <revId>] [--cache] [--model <provider>]
+  wikihistory analyze --pages-file <path> [--depth brief|detailed|forensic] [--cache] [--model <provider>]
+  wikihistory claim <page> --text "<claim text>" [--cache] [--model <provider>]
+  wikihistory export <page> --format json|csv [--bundle] [--model <provider>]
   wikihistory watch <page> [--section <name>]
+  wikihistory eval [--page <title>]
 
 Options:
-  --depth      Analysis depth (default: detailed)
-  --text       Claim text to track across revisions
-  --format     Export format (json, csv)
-  --section    Watch a specific section only
-  --from       Start revision ID
-  --to         End revision ID
-  --cache      Cache revisions in SQLite (~/.wikihistory/varia.db)
+  --depth          Analysis depth (default: detailed)
+  --text           Claim text to track across revisions
+  --format         Export format (json, csv)
+  --section        Watch a specific section only
+  --from           Start revision ID
+  --to             End revision ID
+  --cache          Cache revisions in SQLite (~/.wikihistory/varia.db)
+  --model          Model provider for semantic interpretation (openai, anthropic, deepseek, local, byok)
+  --model-api-key  API key for model provider (or set env var OPENAI_API_KEY etc.)
+  --model-name     Model name override (default: provider-specific)
+  --model-endpoint API endpoint override
+  --api            MediaWiki API base URL (default: https://en.wikipedia.org/w/api.php)
 `;
 
 export async function cli(args: string[]): Promise<void> {
@@ -28,33 +37,59 @@ export async function cli(args: string[]): Promise<void> {
   switch (command) {
     case "analyze": {
       const pageTitle = args[1];
-      if (!pageTitle) {
-        console.error("Usage: wikihistory analyze <page> [--depth brief|detailed|forensic] [--cache]");
-        process.exit(1);
-      }
+      const pagesFile = parseFlag(args, "pages-file");
       const depth = parseFlag(args, "depth") ?? "detailed";
       const fromRev = parseFlag(args, "from");
       const toRev = parseFlag(args, "to");
       const useCache = args.includes("--cache");
+      const modelConfig = parseModelConfig(args);
+      const apiUrl = parseFlag(args, "api");
 
-      const events = await runAnalyze(
-        pageTitle,
-        depth,
-        fromRev ? parseInt(fromRev, 10) : undefined,
-        toRev ? parseInt(toRev, 10) : undefined,
-        useCache,
-      );
+      if (pagesFile) {
+        const result = await runAnalyze(
+          "",
+          depth,
+          fromRev ? parseInt(fromRev, 10) : undefined,
+          toRev ? parseInt(toRev, 10) : undefined,
+          useCache,
+          modelConfig,
+          apiUrl,
+          pagesFile,
+        );
+        const events = result.events;
+        console.log(`\nBatch complete. Total events: ${events.length}`);
+      } else {
+        if (!pageTitle) {
+          console.error("Usage: wikihistory analyze <page> [--depth brief|detailed|forensic] [--cache] [--model <provider>]");
+          process.exit(1);
+        }
+        const { events } = await runAnalyze(
+          pageTitle,
+          depth,
+          fromRev ? parseInt(fromRev, 10) : undefined,
+          toRev ? parseInt(toRev, 10) : undefined,
+          useCache,
+          modelConfig,
+          apiUrl,
+        );
 
-      console.log(`\n=== Analysis Results ===`);
-      console.log(`Page: ${pageTitle}`);
-      console.log(`Events detected: ${events.length}`);
-      console.log();
+        console.log(`\n=== Analysis Results ===`);
+        console.log(`Page: ${pageTitle}`);
+        console.log(`Events detected: ${events.length}`);
+        console.log();
 
-      for (const event of events) {
-        console.log(`[${event.timestamp}] ${event.eventType} (rev ${event.fromRevisionId}→${event.toRevisionId})`);
-        if (event.section) console.log(`  Section: ${event.section}`);
-        for (const fact of event.deterministicFacts) {
-          console.log(`  • ${fact.fact}${fact.detail ? `: ${fact.detail}` : ""}`);
+        for (const event of events) {
+          console.log(`[${event.timestamp}] ${event.eventType} (rev ${event.fromRevisionId}→${event.toRevisionId})`);
+          if (event.section) console.log(`  Section: ${event.section}`);
+          for (const fact of event.deterministicFacts) {
+            console.log(`  • ${fact.fact}${fact.detail ? `: ${fact.detail}` : ""}`);
+          }
+          if (event.modelInterpretation) {
+            console.log(`  ↳ ${event.modelInterpretation.semanticChange} (confidence: ${event.modelInterpretation.confidence.toFixed(2)})`);
+            if (event.modelInterpretation.policyDimension) {
+              console.log(`  ↳ policy: ${event.modelInterpretation.policyDimension}`);
+            }
+          }
         }
       }
       break;
@@ -63,21 +98,26 @@ export async function cli(args: string[]): Promise<void> {
       const pageTitle = args[1];
       const claimText = parseFlag(args, "text");
       if (!pageTitle || !claimText) {
-        console.error('Usage: wikihistory claim <page> --text "<claim text>" [--cache]');
+        console.error('Usage: wikihistory claim <page> --text "<claim text>" [--cache] [--model <provider>]');
         process.exit(1);
       }
       const useCache = args.includes("--cache");
-      await runClaim(pageTitle, claimText, useCache);
+      const modelConfig = parseModelConfig(args);
+      const apiUrl = parseFlag(args, "api");
+      await runClaim(pageTitle, claimText, useCache, modelConfig, apiUrl);
       break;
     }
     case "export": {
       const pageTitle = args[1];
       const format = parseFlag(args, "format") ?? "json";
+      const bundle = args.includes("--bundle");
       if (!pageTitle) {
-        console.error("Usage: wikihistory export <page> --format json|csv");
+        console.error("Usage: wikihistory export <page> --format json|csv [--bundle] [--model <provider>]");
         process.exit(1);
       }
-      await runExport(pageTitle, format);
+      const modelConfig = parseModelConfig(args);
+      const apiUrl = parseFlag(args, "api");
+      await runExport(pageTitle, format, modelConfig, apiUrl, bundle);
       break;
     }
     case "watch": {
@@ -87,7 +127,13 @@ export async function cli(args: string[]): Promise<void> {
         process.exit(1);
       }
       const section = parseFlag(args, "section");
-      await runWatch(pageTitle, section);
+      const apiUrl = parseFlag(args, "api");
+      await runWatch(pageTitle, section, apiUrl);
+      break;
+    }
+    case "eval": {
+      const pageOverride = parseFlag(args, "page");
+      await runEval(pageOverride);
       break;
     }
     case "--help":
@@ -109,3 +155,20 @@ export function parseFlag(args: string[], name: string): string | undefined {
   }
   return undefined;
 }
+
+function parseModelConfig(args: string[]): ModelConfig | undefined {
+  const provider = parseFlag(args, "model");
+  if (!provider) return undefined;
+
+  if (!["openai", "anthropic", "deepseek", "local", "byok"].includes(provider)) {
+    console.error(`Unknown model provider: ${provider}. Use openai, anthropic, deepseek, local, or byok.`);
+    process.exit(1);
+  }
+
+  return {
+    provider: provider as ModelConfig["provider"],
+    apiKey: parseFlag(args, "model-api-key"),
+    model: parseFlag(args, "model-name"),
+    endpoint: parseFlag(args, "model-endpoint"),
+  };
+}