@var-ia/cli 0.1.0

package/src/commands/export.ts

@@ -0,0 +1,87 @@
+import { runAnalyze } from "./analyze.js";
+import type { EvidenceEvent, Report } from "@var-ia/evidence-graph";
+
+export async function runExport(
+  pageTitle: string,
+  format: string,
+): Promise<void> {
+  const events = await runAnalyze(pageTitle, "detailed");
+
+  if (events.length === 0) {
+    console.log("No events to export.");
+    return;
+  }
+
+  if (format === "json") {
+    const report = buildReport(pageTitle, events);
+    console.log(JSON.stringify(report, null, 2));
+  } else if (format === "csv") {
+    console.log(toCSV(events));
+  } else {
+    console.log(JSON.stringify(events, null, 2));
+  }
+}
+
+function buildReport(pageTitle: string, events: EvidenceEvent[]): Report {
+  const sortedRevs = events.map((e) => e.toRevisionId).sort((a, b) => a - b);
+  const timestamps = events.map((e) => e.timestamp).sort();
+
+  return {
+    pageTitle,
+    pageId: 0,
+    analyzedRevisionRange: {
+      from: sortedRevs[0] ?? 0,
+      to: sortedRevs[sortedRevs.length - 1] ?? 0,
+    },
+    generatedAt: new Date().toISOString(),
+    depth: "detailed",
+    layers: [
+      { label: "observed", description: "Deterministic", events: events.length, reproducible: true },
+    ],
+    timeline: {
+      totalRevisions: sortedRevs.length,
+      analyzedRevisions: sortedRevs.length,
+      dateRange: {
+        start: timestamps[0] ?? "",
+        end: timestamps[timestamps.length - 1] ?? "",
+      },
+      events: events.map((e) => ({
+        revisionId: e.toRevisionId,
+        timestamp: e.timestamp,
+        eventType: e.eventType,
+        summary: e.deterministicFacts.map((f) => f.fact).join("; "),
+        layer: e.layer,
+      })),
+    },
+    claims: [],
+    sources: [],
+    policySignals: [],
+    caveats: ["Deterministic analysis only — no model interpretation applied."],
+    phase: "Phase 1b",
+  };
+}
+
+function toCSV(events: EvidenceEvent[]): string {
+  const header = "timestamp,eventType,fromRevisionId,toRevisionId,section,before,after,facts";
+  const rows = events.map((e) => {
+    const facts = e.deterministicFacts.map((f) => f.fact + (f.detail ? `:${f.detail}` : "")).join("; ");
+    return [
+      e.timestamp,
+      e.eventType,
+      e.fromRevisionId,
+      e.toRevisionId,
+      csvEscape(e.section),
+      csvEscape(e.before.slice(0, 200)),
+      csvEscape(e.after.slice(0, 200)),
+      csvEscape(facts),
+    ].join(",");
+  });
+  return [header, ...rows].join("\n");
+}
+
+function csvEscape(val: string): string {
+  if (val.includes(",") || val.includes('"') || val.includes("\n")) {
+    return `"${val.replace(/"/g, '""')}"`;
+  }
+  return val;
+}

package/src/commands/watch.ts

@@ -0,0 +1,145 @@
+import { MediaWikiClient } from "@var-ia/ingestion";
+import { sectionDiffer, citationTracker, templateTracker, revertDetector } from "@var-ia/analyzers";
+import type { EvidenceEvent, EvidenceLayer } from "@var-ia/evidence-graph";
+
+const POLL_INTERVAL_MS = 60_000;
+
+export async function runWatch(
+  pageTitle: string,
+  section?: string,
+): Promise<void> {
+  const client = new MediaWikiClient();
+  console.log(`Watching "${pageTitle}"${section ? ` section="${section}"` : ""}`);
+  console.log(`Polling every ${POLL_INTERVAL_MS / 1000}s. Press Ctrl+C to stop.\n`);
+
+  let lastSeenRevId = 0;
+
+  const poll = async () => {
+    try {
+      const revisions = await client.fetchRevisions(pageTitle, { limit: 5, direction: "newer" });
+      if (revisions.length === 0) return;
+
+      const sortedRevs = [...revisions].sort(
+        (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+      );
+
+      const newRevs = sortedRevs.filter((r) => r.revId > lastSeenRevId);
+      if (newRevs.length === 0) return;
+
+      if (lastSeenRevId === 0) {
+        const latest = sortedRevs[sortedRevs.length - 1];
+        console.log(`[${new Date().toISOString()}] Initial watch — latest revision: ${latest.revId} (${latest.timestamp})`);
+        lastSeenRevId = latest.revId;
+        return;
+      }
+
+      for (const rev of newRevs) {
+        const events: EvidenceEvent[] = [];
+        const layer: EvidenceLayer = "observed";
+
+        const prevIdx = sortedRevs.findIndex((r) => r.revId === rev.revId) - 1;
+        if (prevIdx >= 0) {
+          const before = sortedRevs[prevIdx];
+          const citeChanges = citationTracker.diffCitations(
+            citationTracker.extractCitations(before.content),
+            citationTracker.extractCitations(rev.content),
+          );
+
+          for (const cit of citeChanges) {
+            if (cit.type === "unchanged") continue;
+            events.push({
+              eventType: cit.type === "added" ? "citation_added" : cit.type === "removed" ? "citation_removed" : "citation_replaced",
+              fromRevisionId: before.revId,
+              toRevisionId: rev.revId,
+              section: "body",
+              before: cit.before?.raw ?? "",
+              after: cit.after?.raw ?? "",
+              deterministicFacts: [{ fact: "citation_changed", detail: `type=${cit.type}` }],
+              layer,
+              timestamp: rev.timestamp,
+            });
+          }
+
+          const tplChanges = templateTracker.diffTemplates(
+            templateTracker.extractTemplates(before.content),
+            templateTracker.extractTemplates(rev.content),
+          );
+          for (const tpl of tplChanges) {
+            if (tpl.type === "unchanged") continue;
+            events.push({
+              eventType: tpl.type === "added" ? "template_added" : "template_removed",
+              fromRevisionId: before.revId,
+              toRevisionId: rev.revId,
+              section: "body",
+              before: "",
+              after: tpl.template.name,
+              deterministicFacts: [{ fact: "template_changed", detail: `name=${tpl.template.name} type=${tpl.type}` }],
+              layer,
+              timestamp: rev.timestamp,
+            });
+          }
+
+          if (revertDetector.isRevert(rev.comment)) {
+            events.push({
+              eventType: "revert_detected",
+              fromRevisionId: before.revId,
+              toRevisionId: rev.revId,
+              section: "",
+              before: "",
+              after: rev.comment,
+              deterministicFacts: [{ fact: "revert_detected", detail: rev.comment }],
+              layer,
+              timestamp: rev.timestamp,
+            });
+          }
+
+          const secChanges = sectionDiffer.diffSections(
+            sectionDiffer.extractSections(before.content),
+            sectionDiffer.extractSections(rev.content),
+          );
+          for (const sc of secChanges) {
+            if (sc.changeType === "unchanged") continue;
+            if (section && sc.section !== section) continue;
+            events.push({
+              eventType: "section_reorganized",
+              fromRevisionId: before.revId,
+              toRevisionId: rev.revId,
+              section: sc.section,
+              before: sc.fromContent ?? "",
+              after: sc.toContent ?? "",
+              deterministicFacts: [{ fact: "section_changed", detail: `change=${sc.changeType}` }],
+              layer,
+              timestamp: rev.timestamp,
+            });
+          }
+        }
+
+        console.log(`\n[${rev.timestamp}] NEW REVISION ${rev.revId}`);
+        console.log(`  Comment: ${rev.comment || "(none)"}`);
+        console.log(`  Size: ${rev.size} bytes`);
+        if (events.length > 0) {
+          console.log(`  Events: ${events.length}`);
+          for (const e of events) {
+            console.log(`    - ${e.eventType} ${e.deterministicFacts.map((f) => f.detail).join(", ")}`);
+          }
+        }
+      }
+
+      lastSeenRevId = sortedRevs[sortedRevs.length - 1].revId;
+    } catch (err) {
+      console.error(`[${new Date().toISOString()}] Watch error:`, (err as Error).message);
+    }
+  };
+
+  await poll();
+  const interval = setInterval(poll, POLL_INTERVAL_MS);
+
+  const shutdown = () => {
+    clearInterval(interval);
+    console.log("\nWatch stopped.");
+    process.exit(0);
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}

package/src/index.ts

@@ -0,0 +1,111 @@
+import { runAnalyze } from "./commands/analyze.js";
+import { runClaim } from "./commands/claim.js";
+import { runExport } from "./commands/export.js";
+import { runWatch } from "./commands/watch.js";
+
+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 watch <page> [--section <name>]
+
+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)
+`;
+
+export async function cli(args: string[]): Promise<void> {
+  const command = args[0];
+
+  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 depth = parseFlag(args, "depth") ?? "detailed";
+      const fromRev = parseFlag(args, "from");
+      const toRev = parseFlag(args, "to");
+      const useCache = args.includes("--cache");
+
+      const events = await runAnalyze(
+        pageTitle,
+        depth,
+        fromRev ? parseInt(fromRev, 10) : undefined,
+        toRev ? parseInt(toRev, 10) : undefined,
+        useCache,
+      );
+
+      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}` : ""}`);
+        }
+      }
+      break;
+    }
+    case "claim": {
+      const pageTitle = args[1];
+      const claimText = parseFlag(args, "text");
+      if (!pageTitle || !claimText) {
+        console.error('Usage: wikihistory claim <page> --text "<claim text>" [--cache]');
+        process.exit(1);
+      }
+      const useCache = args.includes("--cache");
+      await runClaim(pageTitle, claimText, useCache);
+      break;
+    }
+    case "export": {
+      const pageTitle = args[1];
+      const format = parseFlag(args, "format") ?? "json";
+      if (!pageTitle) {
+        console.error("Usage: wikihistory export <page> --format json|csv");
+        process.exit(1);
+      }
+      await runExport(pageTitle, format);
+      break;
+    }
+    case "watch": {
+      const pageTitle = args[1];
+      if (!pageTitle) {
+        console.error("Usage: wikihistory watch <page> [--section <name>]");
+        process.exit(1);
+      }
+      const section = parseFlag(args, "section");
+      await runWatch(pageTitle, section);
+      break;
+    }
+    case "--help":
+    case "-h":
+    default:
+      console.log(HELP);
+      break;
+  }
+}
+
+export function parseFlag(args: string[], name: string): string | undefined {
+  const idx = args.indexOf(`--${name}`);
+  if (idx >= 0 && idx + 1 < args.length) {
+    return args[idx + 1];
+  }
+  const eqIdx = args.findIndex((a) => a.startsWith(`--${name}=`));
+  if (eqIdx >= 0) {
+    return args[eqIdx].split("=")[1];
+  }
+  return undefined;
+}