@djolex999/vir-cli 0.1.0 → 0.1.1

package/src/lint/linter.ts

@@ -1,286 +0,0 @@
-import { readFileSync, readdirSync, statSync } from "node:fs";
-import { join, relative } from "node:path";
-import type { Config } from "../config.js";
-import type { DistilledRow, StateDb } from "../state/db.js";
-import {
-  buildAnthropicClient,
-  callLLM,
-  normalizeModelName,
-  withRateLimitRetry,
-} from "../pipeline/distiller.js";
-import { kebab } from "../pipeline/writer.js";
-
-const SKIP_BASENAMES = new Set(["index.md", "log.md"]);
-const SKIP_DIRS = new Set(["projects"]);
-const CATEGORY_DIRS = ["patterns", "gotchas", "decisions", "tools"];
-const STALE_AGE_DAYS = 90;
-const RECENT_AGE_DAYS = 30;
-const MAX_CONTRADICTION_PAIRS = 20;
-
-export interface OrphanResult {
-  orphans: string[];
-}
-
-export interface StaleEntry {
-  relPath: string;
-  project: string;
-  ageDays: number;
-  newerSameProjectCount: number;
-  startedAt: string;
-}
-
-export interface ContradictionEntry {
-  a: string;
-  b: string;
-  reason: string;
-}
-
-export interface ContradictionResult {
-  checked: number;
-  contradictions: ContradictionEntry[];
-}
-
-interface NoteFile {
-  relPath: string;
-  noteRef: string;
-  id: string;
-  raw: string;
-}
-
-export function orphanCheck(cfg: Config): OrphanResult {
-  const notes = loadVaultNotes(cfg);
-  const idSet = new Set(notes.map((n) => n.id));
-
-  const outgoing = new Map<string, Set<string>>();
-  const incoming = new Map<string, Set<string>>();
-
-  for (const n of notes) {
-    const targets = new Set<string>();
-    const linkRe = /\[\[([^\]\n]+?)\]\]/g;
-    let m: RegExpExecArray | null;
-    while ((m = linkRe.exec(n.raw)) !== null) {
-      const inner = (m[1] ?? "").trim();
-      if (inner.length === 0) continue;
-      const target = inner.split("|")[0]?.trim() ?? inner;
-      const tail = target.includes("/")
-        ? (target.split("/").pop() ?? target)
-        : target;
-      // Only count links that resolve to actual note files; Project/Category
-      // virtual nodes (e.g. [[growthq]], [[pattern]]) don't count.
-      if (idSet.has(tail) && tail !== n.id) {
-        targets.add(tail);
-        if (!incoming.has(tail)) incoming.set(tail, new Set());
-        incoming.get(tail)!.add(n.id);
-      }
-    }
-    outgoing.set(n.id, targets);
-  }
-
-  const orphans: string[] = [];
-  for (const n of notes) {
-    const out = outgoing.get(n.id) ?? new Set();
-    const inc = incoming.get(n.id) ?? new Set();
-    if (out.size === 0 && inc.size === 0) orphans.push(n.noteRef);
-  }
-  orphans.sort();
-  return { orphans };
-}
-
-export function stalenessCheck(_cfg: Config, db: StateDb): StaleEntry[] {
-  const rows = db.listDistilled();
-  const now = Date.now();
-  const day = 24 * 60 * 60 * 1000;
-
-  const parsed = rows
-    .map((r) => ({ r, t: r.startedAt ? Date.parse(r.startedAt) : NaN }))
-    .filter((x) => Number.isFinite(x.t));
-
-  const stale: StaleEntry[] = [];
-  for (const { r, t } of parsed) {
-    const ageDays = Math.floor((now - t) / day);
-    if (ageDays < STALE_AGE_DAYS) continue;
-    const projectSlug = kebab(r.project);
-
-    const hasRecentSameCat = parsed.some(
-      (x) =>
-        kebab(x.r.project) === projectSlug &&
-        x.r.category === r.category &&
-        x.t > t &&
-        (now - x.t) / day <= RECENT_AGE_DAYS,
-    );
-    if (!hasRecentSameCat) continue;
-
-    const newerSameProj = parsed.filter(
-      (x) => kebab(x.r.project) === projectSlug && x.t > t,
-    ).length;
-
-    stale.push({
-      relPath: noteRef(r),
-      project: projectSlug,
-      ageDays,
-      newerSameProjectCount: newerSameProj,
-      startedAt: r.startedAt ?? "",
-    });
-  }
-
-  stale.sort((a, b) => b.ageDays - a.ageDays);
-  return stale;
-}
-
-interface CandidatePair {
-  a: DistilledRow;
-  b: DistilledRow;
-  score: number;
-}
-
-export async function contradictionCheck(
-  cfg: Config,
-  db: StateDb,
-): Promise<ContradictionResult> {
-  const rows = db.listDistilled();
-  const pairs = rankCandidatePairs(rows).slice(0, MAX_CONTRADICTION_PAIRS);
-
-  if (pairs.length === 0) {
-    return { checked: 0, contradictions: [] };
-  }
-
-  const client = buildAnthropicClient(cfg);
-  const model = normalizeModelName(cfg.models.classify, cfg.provider);
-  const contradictions: ContradictionEntry[] = [];
-
-  for (const pair of pairs) {
-    const prompt = `Do these two knowledge notes contradict each other?
-Answer JSON only: { "contradicts": boolean, "reason": "string (max 20 words)" }
-
-Note A (topic: ${pair.a.topic}):
-${excerpt(pair.a.content)}
-
-Note B (topic: ${pair.b.topic}):
-${excerpt(pair.b.content)}`;
-
-    try {
-      const text = await withRateLimitRetry(() =>
-        callLLM(cfg, client, { prompt, model, maxTokens: 200 }),
-      );
-      const parsed = parseContradictionResponse(text);
-      if (parsed.contradicts) {
-        contradictions.push({
-          a: noteRef(pair.a),
-          b: noteRef(pair.b),
-          reason: parsed.reason,
-        });
-      }
-    } catch {
-      // ignore individual pair failures — don't abort the whole check
-    }
-  }
-
-  return { checked: pairs.length, contradictions };
-}
-
-function rankCandidatePairs(rows: DistilledRow[]): CandidatePair[] {
-  const pairs: CandidatePair[] = [];
-  for (let i = 0; i < rows.length; i += 1) {
-    const a = rows[i];
-    if (!a) continue;
-    for (let j = i + 1; j < rows.length; j += 1) {
-      const b = rows[j];
-      if (!b) continue;
-      const sameProjCat =
-        kebab(a.project) === kebab(b.project) && a.category === b.category;
-      const sharedTokens = countSharedTokens(a.topic, b.topic);
-      if (!sameProjCat && sharedTokens < 2) continue;
-      const score = (sameProjCat ? 2 : 0) + sharedTokens;
-      pairs.push({ a, b, score });
-    }
-  }
-  pairs.sort((x, y) => y.score - x.score);
-  return pairs;
-}
-
-function countSharedTokens(a: string, b: string): number {
-  const at = new Set(kebab(a).split("-").filter((t) => t.length >= 3));
-  let n = 0;
-  for (const t of kebab(b).split("-")) {
-    if (t.length >= 3 && at.has(t)) n += 1;
-  }
-  return n;
-}
-
-function parseContradictionResponse(text: string): {
-  contradicts: boolean;
-  reason: string;
-} {
-  const match = text.match(/\{[\s\S]*\}/);
-  if (!match) return { contradicts: false, reason: "" };
-  try {
-    const obj = JSON.parse(match[0]) as Record<string, unknown>;
-    return {
-      contradicts: obj.contradicts === true,
-      reason: typeof obj.reason === "string" ? obj.reason : "",
-    };
-  } catch {
-    return { contradicts: false, reason: "" };
-  }
-}
-
-function excerpt(s: string): string {
-  return s.replace(/\s+/g, " ").trim().slice(0, 300);
-}
-
-function loadVaultNotes(cfg: Config): NoteFile[] {
-  const root = join(cfg.vaultPath, cfg.outputDir);
-  const files: string[] = [];
-  walkVault(root, files);
-
-  const notes: NoteFile[] = [];
-  for (const full of files) {
-    const rel = relative(root, full);
-    const parts = rel.split("/");
-    const base = parts[parts.length - 1] ?? "";
-    if (SKIP_BASENAMES.has(base)) continue;
-    const firstDir = parts[0] ?? "";
-    if (SKIP_DIRS.has(firstDir)) continue;
-    if (!CATEGORY_DIRS.includes(firstDir)) continue;
-    let raw: string;
-    try {
-      raw = readFileSync(full, "utf8");
-    } catch {
-      continue;
-    }
-    notes.push({
-      relPath: rel,
-      noteRef: rel.replace(/\.md$/, ""),
-      id: base.replace(/\.md$/, ""),
-      raw,
-    });
-  }
-  return notes;
-}
-
-function walkVault(dir: string, acc: string[]): void {
-  let entries: string[];
-  try {
-    entries = readdirSync(dir);
-  } catch {
-    return;
-  }
-  for (const name of entries) {
-    const full = join(dir, name);
-    let st: ReturnType<typeof statSync>;
-    try {
-      st = statSync(full);
-    } catch {
-      continue;
-    }
-    if (st.isDirectory()) walkVault(full, acc);
-    else if (st.isFile() && name.endsWith(".md")) acc.push(full);
-  }
-}
-
-function noteRef(r: DistilledRow): string {
-  const dir = `${r.category}s`;
-  const slug = kebab(r.topic);
-  const suffix = r.sessionId.slice(0, 8);
-  return `${dir}/${slug}-${suffix}`;
-}

package/src/pipeline/distiller.ts

@@ -1,280 +0,0 @@
-import Anthropic from "@anthropic-ai/sdk";
-import type { Config } from "../config.js";
-import type {
-  Category,
-  Classification,
-  DistilledNote,
-  ParsedSession,
-} from "./types.js";
-
-const CATEGORIES: Category[] = ["pattern", "gotcha", "decision", "tool"];
-
-class HttpError extends Error {
-  status: number;
-  constructor(status: number, message: string) {
-    super(message);
-    this.status = status;
-    this.name = "HttpError";
-  }
-}
-
-export function buildAnthropicClient(config: Config): Anthropic {
-  return new Anthropic({ apiKey: config.anthropicApiKey ?? "" });
-}
-
-// Canonical model IDs accepted by Kie's /claude/v1/messages endpoint.
-// Anything that *starts with* one of these keys collapses to the bare ID,
-// so a stray suffix in config (date stamp, accidental path fragment like
-// "v1messages", etc.) can't corrupt the outgoing model string.
-const KIE_CANONICAL_MODELS = ["claude-haiku-4-5", "claude-sonnet-4-6"] as const;
-
-export function normalizeModelName(model: string, provider: string): string {
-  if (provider !== "kie") return model;
-  for (const canonical of KIE_CANONICAL_MODELS) {
-    if (model.startsWith(canonical)) return canonical;
-  }
-  // Fallback: still strip a trailing -YYYYMMDD date suffix.
-  return model.replace(/-\d{8}$/, "");
-}
-
-interface KieResponseBlock {
-  type?: string;
-  text?: string;
-}
-interface KieResponse {
-  content?: KieResponseBlock[];
-  error?: { message?: string };
-}
-
-async function callKie(opts: {
-  apiKey: string;
-  model: string;
-  maxTokens: number;
-  prompt: string;
-}): Promise<string> {
-  const response = await fetch("https://api.kie.ai/claude/v1/messages", {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${opts.apiKey}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({
-      model: opts.model,
-      max_tokens: opts.maxTokens,
-      messages: [{ role: "user", content: opts.prompt }],
-    }),
-  });
-
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    throw new HttpError(
-      response.status,
-      `Kie ${response.status}: ${body.slice(0, 500)}`,
-    );
-  }
-
-  const data = (await response.json()) as KieResponse;
-  const text = data.content?.[0]?.text ?? "";
-  return text;
-}
-
-async function callAnthropic(opts: {
-  client: Anthropic;
-  model: string;
-  maxTokens: number;
-  prompt: string;
-}): Promise<string> {
-  const resp = await opts.client.messages.create({
-    model: opts.model,
-    max_tokens: opts.maxTokens,
-    messages: [{ role: "user", content: opts.prompt }],
-  });
-  const parts: string[] = [];
-  for (const block of resp.content) {
-    if (block.type === "text") parts.push(block.text);
-  }
-  return parts.join("\n");
-}
-
-export interface LlmCallOpts {
-  prompt: string;
-  model: string;
-  maxTokens: number;
-}
-
-export async function callLLM(
-  config: Config,
-  client: Anthropic,
-  opts: LlmCallOpts,
-): Promise<string> {
-  if (config.provider === "kie") {
-    return callKie({
-      apiKey: config.kieApiKey ?? "",
-      model: opts.model,
-      maxTokens: opts.maxTokens,
-      prompt: opts.prompt,
-    });
-  }
-  return callAnthropic({
-    client,
-    model: opts.model,
-    maxTokens: opts.maxTokens,
-    prompt: opts.prompt,
-  });
-}
-
-export class Distiller {
-  private client: Anthropic;
-  private cfg: Config;
-  private classifyModel: string;
-  private distillModel: string;
-
-  constructor(cfg: Config) {
-    this.cfg = cfg;
-    this.client = buildAnthropicClient(cfg);
-    this.classifyModel = normalizeModelName(cfg.models.classify, cfg.provider);
-    this.distillModel = normalizeModelName(cfg.models.distill, cfg.provider);
-  }
-
-  async classify(
-    session: ParsedSession,
-    scrubbedSummary: string,
-  ): Promise<Classification> {
-    const prompt = `Given this Claude Code session summary, output JSON only:
-{ "category": "pattern" | "gotcha" | "decision" | "tool",
-  "topic": string (2-4 words, kebab-friendly),
-  "project": string,
-  "confidence": number (0..1) }
-
-Project slug from path: ${session.projectSlug}
-
-Session:
-${scrubbedSummary}`;
-
-    const text = await withRateLimitRetry(() =>
-      callLLM(this.cfg, this.client, {
-        prompt,
-        model: this.classifyModel,
-        maxTokens: 400,
-      }),
-    );
-    return parseClassification(text, session.projectSlug);
-  }
-
-  async distill(
-    session: ParsedSession,
-    scrubbedContent: string,
-    cls: Classification,
-  ): Promise<string> {
-    const prompt = `Extract durable knowledge from this Claude Code session.
-
-Output a markdown page with these sections (no preamble, start with '## Summary'):
-- ## Summary (2-3 sentences)
-- ## What Was Learned
-- ## Context (project: ${cls.project}, category: ${cls.category}, date: ${session.startedAt ?? "unknown"})
-- ## Related
-
-Be concise. Only include information a future developer would reuse.
-Omit implementation details that won't generalize.
-
-Session:
-${scrubbedContent}`;
-
-    const text = await withRateLimitRetry(() =>
-      callLLM(this.cfg, this.client, {
-        prompt,
-        model: this.distillModel,
-        maxTokens: 1500,
-      }),
-    );
-    return text.trim();
-  }
-
-  async run(
-    session: ParsedSession,
-    scrubbedSummary: string,
-    scrubbedContent: string,
-  ): Promise<DistilledNote | null> {
-    const cls = await this.classify(session, scrubbedSummary);
-    if (cls.confidence <= 0.6) return null;
-    const md = await this.distill(session, scrubbedContent, cls);
-    return { classification: cls, markdown: md };
-  }
-}
-
-const RETRY_DELAYS_MS = [60_000, 120_000, 240_000];
-
-function isRateLimit(err: unknown): boolean {
-  if (!err || typeof err !== "object") return false;
-  const e = err as { status?: number; statusCode?: number };
-  if (e.status === 429 || e.statusCode === 429) return true;
-  if (err instanceof Anthropic.APIError && err.status === 429) return true;
-  if (err instanceof HttpError && err.status === 429) return true;
-  return false;
-}
-
-async function sleep(ms: number): Promise<void> {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-export async function withRateLimitRetry<T>(fn: () => Promise<T>): Promise<T> {
-  for (let attempt = 0; attempt < RETRY_DELAYS_MS.length; attempt += 1) {
-    try {
-      return await fn();
-    } catch (err) {
-      if (!isRateLimit(err)) throw err;
-      const delay = RETRY_DELAYS_MS[attempt] ?? 240_000;
-      console.warn(
-        `[vir] 429 rate limit — retry ${attempt + 1}/${RETRY_DELAYS_MS.length} in ${delay / 1000}s`,
-      );
-      await sleep(delay);
-    }
-  }
-  return await fn();
-}
-
-function parseClassification(
-  text: string,
-  fallbackProject: string,
-): Classification {
-  const jsonMatch = text.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) {
-    return {
-      category: "pattern",
-      topic: "unknown",
-      project: fallbackProject,
-      confidence: 0,
-    };
-  }
-  let obj: Record<string, unknown>;
-  try {
-    obj = JSON.parse(jsonMatch[0]) as Record<string, unknown>;
-  } catch {
-    return {
-      category: "pattern",
-      topic: "unknown",
-      project: fallbackProject,
-      confidence: 0,
-    };
-  }
-  const rawCat = typeof obj.category === "string" ? obj.category : "pattern";
-  const category: Category = (CATEGORIES as string[]).includes(rawCat)
-    ? (rawCat as Category)
-    : "pattern";
-  const topic =
-    typeof obj.topic === "string" && obj.topic.trim().length > 0
-      ? obj.topic.trim()
-      : "unknown";
-  const project =
-    typeof obj.project === "string" && obj.project.trim().length > 0
-      ? obj.project.trim()
-      : fallbackProject;
-  const confidenceRaw =
-    typeof obj.confidence === "number"
-      ? obj.confidence
-      : Number(obj.confidence ?? 0);
-  const confidence = Number.isFinite(confidenceRaw)
-    ? Math.max(0, Math.min(1, confidenceRaw))
-    : 0;
-  return { category, topic, project, confidence };
-}

package/src/pipeline/filter.ts

@@ -1,43 +0,0 @@
-import type { ParsedSession } from "./types.js";
-
-const SIGNAL_REGEX = /\b(error|fixed|bug|learned|gotcha|workaround|fixed it|root cause)\b/i;
-
-export interface FilterResult {
-  score: number;
-  passes: boolean;
-  reasons: string[];
-}
-
-export function scoreSession(
-  session: ParsedSession,
-  threshold: number,
-): FilterResult {
-  let score = 0;
-  const reasons: string[] = [];
-
-  if (session.lineCount > 50) {
-    score += 0.3;
-    reasons.push(`lineCount>50 (+0.3)`);
-  }
-  if (session.toolCallCount > 5) {
-    score += 0.3;
-    reasons.push(`toolCalls>5 (+0.3)`);
-  }
-  if (session.filesTouched.length > 2) {
-    score += 0.2;
-    reasons.push(`files>2 (+0.2)`);
-  }
-  if (
-    SIGNAL_REGEX.test(session.assistantText) ||
-    SIGNAL_REGEX.test(session.userText)
-  ) {
-    score += 0.2;
-    reasons.push(`signal-word (+0.2)`);
-  }
-
-  return {
-    score: Math.round(score * 100) / 100,
-    passes: score >= threshold,
-    reasons,
-  };
-}