caik-cli 0.1.1 → 0.6.0

package/dist/daemon/eval-generator-OR2FAYLB.js

@@ -0,0 +1,316 @@
+import {
+  getTraceCount,
+  getTraces
+} from "./chunk-NJICGNCK.js";
+import {
+  runSingleCase
+} from "./chunk-UMDJFPN6.js";
+import {
+  callAnthropic,
+  parseLLMJson
+} from "./chunk-SM2FSXIP.js";
+import "./chunk-MLKGABMK.js";
+
+// src/daemon/eval-generator.ts
+import { randomUUID } from "crypto";
+function rowToEvalCase(row) {
+  const value = JSON.parse(row.assertion_value);
+  let assertion;
+  switch (row.assertion_type) {
+    case "must_contain":
+      assertion = { type: "must_contain", pattern: value.pattern };
+      break;
+    case "must_not_contain":
+      assertion = { type: "must_not_contain", pattern: value.pattern };
+      break;
+    case "max_output_length":
+      assertion = { type: "max_output_length", tokens: value.tokens };
+      break;
+    case "llm_judge":
+      assertion = { type: "llm_judge", prompt: value.prompt };
+      break;
+    case "code_check":
+      assertion = { type: "code_check", fn: value.fn };
+      break;
+    // Behavioral types
+    case "behavioral_must_contain":
+      assertion = { type: "behavioral_must_contain", scenario: value.scenario, pattern: value.pattern };
+      break;
+    case "behavioral_must_not_contain":
+      assertion = { type: "behavioral_must_not_contain", scenario: value.scenario, pattern: value.pattern };
+      break;
+    case "behavioral_max_length":
+      assertion = { type: "behavioral_max_length", scenario: value.scenario, tokens: value.tokens };
+      break;
+    case "behavioral_judge":
+      assertion = { type: "behavioral_judge", scenario: value.scenario, criteria: value.criteria };
+      break;
+    case "behavioral_code_check":
+      assertion = { type: "behavioral_code_check", scenario: value.scenario, fn: value.fn };
+      break;
+    default:
+      assertion = { type: "must_contain", pattern: "UNKNOWN" };
+  }
+  return {
+    id: row.id,
+    suiteSlug: row.suite_slug,
+    traceId: row.trace_id ?? void 0,
+    source: row.source,
+    category: row.category,
+    assertion,
+    description: row.description
+  };
+}
+function getEvalSuite(db, slug) {
+  const suiteRow = db.prepare("SELECT * FROM eval_suites WHERE slug = ?").get(slug);
+  if (!suiteRow) return null;
+  const caseRows = db.prepare("SELECT * FROM eval_cases WHERE suite_slug = ? ORDER BY created_at ASC").all(slug);
+  return {
+    slug: suiteRow.slug,
+    version: suiteRow.version,
+    cases: caseRows.map(rowToEvalCase),
+    tpr: suiteRow.tpr ?? void 0,
+    tnr: suiteRow.tnr ?? void 0,
+    validationSampleSize: suiteRow.validation_sample_size ?? void 0,
+    validatedAt: suiteRow.validated_at ?? void 0
+  };
+}
+function shouldGenerateEvals(db, slug) {
+  const counts = getTraceCount(db, slug);
+  if (counts.corrections < 3) return false;
+  const suite = getEvalSuite(db, slug);
+  if (!suite) return true;
+  const processedTraceIds = new Set(
+    suite.cases.filter((c) => c.traceId).map((c) => c.traceId)
+  );
+  const allTraces = getTraces(db, slug, { kind: "correction" });
+  const unprocessed = allTraces.filter((t) => !processedTraceIds.has(t.id));
+  return unprocessed.length > 0;
+}
+var EVAL_GEN_SYSTEM_STRUCTURAL = `You generate eval test cases for Claude Code artifacts (skills, prompts, rules, subagents, commands).
+Given a correction trace \u2014 what the user asked, what the skill produced, how the user corrected it \u2014
+generate ONE eval assertion that would catch this failure pattern.
+
+Prefer deterministic assertions over LLM judges:
+- "must_contain" \u2014 regex pattern that MUST be present in the skill. assertion_value: {"pattern": "regex_here"}
+- "must_not_contain" \u2014 regex pattern that must NOT be present. assertion_value: {"pattern": "regex_here"}
+- "code_check" \u2014 JavaScript function body receiving 'content' argument. assertion_value: {"fn": "return content.includes('...')"}
+- "llm_judge" \u2014 ONLY when pattern-based is impossible. assertion_value: {"prompt": "judge prompt here"}
+
+Return ONLY a JSON object:
+{"assertion_type": "...", "assertion_value": {...}, "category": "...", "description": "One line describing the failure"}`;
+var EVAL_GEN_SYSTEM_BEHAVIORAL = `You generate BEHAVIORAL eval test cases for Claude Code artifacts (skills, prompts, rules, subagents, commands).
+A behavioral eval works by: (1) using the artifact content as a system prompt for an LLM, (2) sending a test scenario as the user message, (3) checking the simulated output.
+
+Given a correction trace, generate ONE behavioral eval assertion with a realistic test scenario.
+
+Available types:
+- "behavioral_must_contain" \u2014 simulated output MUST match regex. assertion_value: {"scenario": "user request that triggers the skill", "pattern": "regex_for_expected_output"}
+- "behavioral_must_not_contain" \u2014 simulated output must NOT match. assertion_value: {"scenario": "...", "pattern": "regex_for_unwanted_output"}
+- "behavioral_max_length" \u2014 output must be under N tokens. assertion_value: {"scenario": "...", "tokens": 200}
+- "behavioral_code_check" \u2014 JS function on output string. assertion_value: {"scenario": "...", "fn": "return content.split('\\n').length < 20"}
+- "behavioral_judge" \u2014 ONLY when pattern-based is impossible. assertion_value: {"scenario": "...", "criteria": "what good output looks like"}
+
+The scenario should be a realistic user request that would expose the weakness found in the correction.
+Prefer behavioral_must_contain and behavioral_must_not_contain over behavioral_judge.
+
+Return ONLY a JSON object:
+{"assertion_type": "behavioral_...", "assertion_value": {...}, "category": "...", "description": "One line describing what the output should/shouldn't do"}`;
+function isBehavioralCorrection(correctionType) {
+  return ["scope_adjusted", "format_changed", "output_modified"].includes(correctionType ?? "");
+}
+async function generateEvalCase(trace, apiKey, model = "claude-haiku-4-5-20251001") {
+  if (!trace.correctionType && !trace.correctionPrompt) return null;
+  const useBehavioral = isBehavioralCorrection(trace.correctionType);
+  const userMessage = `Correction trace:
+- Skill slug: ${trace.slug}
+- Correction type: ${trace.correctionType ?? "unknown"}
+- User's correction message: ${trace.correctionPrompt ?? "(no message captured)"}
+- Tool that was used: ${trace.toolName}
+- Tool input: ${JSON.stringify(trace.toolInput, null, 2).slice(0, 2e3)}
+- Tool response: ${JSON.stringify(trace.toolResponse, null, 2).slice(0, 2e3)}
+
+Generate an eval assertion that would detect this failure pattern.`;
+  try {
+    const result = await callAnthropic(apiKey, {
+      model,
+      system: useBehavioral ? EVAL_GEN_SYSTEM_BEHAVIORAL : EVAL_GEN_SYSTEM_STRUCTURAL,
+      userMessage,
+      maxTokens: 512
+    });
+    const parsed = parseLLMJson(result.text);
+    if (!parsed.assertion_type || !parsed.assertion_value || !parsed.category || !parsed.description) {
+      return null;
+    }
+    let assertion;
+    switch (parsed.assertion_type) {
+      case "must_contain":
+        assertion = { type: "must_contain", pattern: String(parsed.assertion_value.pattern ?? "") };
+        break;
+      case "must_not_contain":
+        assertion = { type: "must_not_contain", pattern: String(parsed.assertion_value.pattern ?? "") };
+        break;
+      case "code_check":
+        assertion = { type: "code_check", fn: String(parsed.assertion_value.fn ?? "") };
+        break;
+      case "llm_judge":
+        assertion = { type: "llm_judge", prompt: String(parsed.assertion_value.prompt ?? "") };
+        break;
+      case "max_output_length":
+        assertion = { type: "max_output_length", tokens: Number(parsed.assertion_value.tokens ?? 500) };
+        break;
+      // Behavioral types
+      case "behavioral_must_contain":
+        assertion = { type: "behavioral_must_contain", scenario: String(parsed.assertion_value.scenario ?? ""), pattern: String(parsed.assertion_value.pattern ?? "") };
+        break;
+      case "behavioral_must_not_contain":
+        assertion = { type: "behavioral_must_not_contain", scenario: String(parsed.assertion_value.scenario ?? ""), pattern: String(parsed.assertion_value.pattern ?? "") };
+        break;
+      case "behavioral_max_length":
+        assertion = { type: "behavioral_max_length", scenario: String(parsed.assertion_value.scenario ?? ""), tokens: Number(parsed.assertion_value.tokens ?? 500) };
+        break;
+      case "behavioral_judge":
+        assertion = { type: "behavioral_judge", scenario: String(parsed.assertion_value.scenario ?? ""), criteria: String(parsed.assertion_value.criteria ?? "") };
+        break;
+      case "behavioral_code_check":
+        assertion = { type: "behavioral_code_check", scenario: String(parsed.assertion_value.scenario ?? ""), fn: String(parsed.assertion_value.fn ?? "") };
+        break;
+      default:
+        return null;
+    }
+    return {
+      evalCase: {
+        traceId: trace.id,
+        source: "trace",
+        category: parsed.category,
+        assertion,
+        description: parsed.description
+      },
+      llmCalls: 1
+    };
+  } catch {
+    return null;
+  }
+}
+function serializeAssertionValue(assertion) {
+  switch (assertion.type) {
+    case "must_contain":
+    case "must_not_contain":
+      return JSON.stringify({ pattern: assertion.pattern });
+    case "code_check":
+      return JSON.stringify({ fn: assertion.fn });
+    case "llm_judge":
+      return JSON.stringify({ prompt: assertion.prompt });
+    case "max_output_length":
+      return JSON.stringify({ tokens: assertion.tokens });
+    case "behavioral_must_contain":
+    case "behavioral_must_not_contain":
+      return JSON.stringify({ scenario: assertion.scenario, pattern: assertion.pattern });
+    case "behavioral_code_check":
+      return JSON.stringify({ scenario: assertion.scenario, fn: assertion.fn });
+    case "behavioral_judge":
+      return JSON.stringify({ scenario: assertion.scenario, criteria: assertion.criteria });
+    case "behavioral_max_length":
+      return JSON.stringify({ scenario: assertion.scenario, tokens: assertion.tokens });
+  }
+}
+var MAX_EVAL_CASES = 20;
+async function generateEvalSuite(db, slug, apiKey, model = "claude-haiku-4-5-20251001") {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let totalLLMCalls = 0;
+  let suite = getEvalSuite(db, slug);
+  if (!suite) {
+    db.prepare(
+      "INSERT INTO eval_suites (slug, version, created_at, updated_at) VALUES (?, 1, ?, ?)"
+    ).run(slug, now, now);
+    suite = { slug, version: 1, cases: [] };
+  }
+  const processedTraceIds = new Set(
+    suite.cases.filter((c) => c.traceId).map((c) => c.traceId)
+  );
+  const correctionTraces = getTraces(db, slug, { kind: "correction" });
+  const unprocessed = correctionTraces.filter((t) => !processedTraceIds.has(t.id));
+  const existingCategories = new Set(suite.cases.map((c) => c.category));
+  for (const trace of unprocessed) {
+    if (suite.cases.length >= MAX_EVAL_CASES) break;
+    if (totalLLMCalls >= MAX_EVAL_CASES) break;
+    const result = await generateEvalCase(trace, apiKey, model);
+    if (!result) continue;
+    totalLLMCalls += result.llmCalls;
+    if (existingCategories.has(result.evalCase.category)) continue;
+    existingCategories.add(result.evalCase.category);
+    const caseId = randomUUID();
+    const assertionValue = serializeAssertionValue(result.evalCase.assertion);
+    db.prepare(
+      `INSERT INTO eval_cases (id, suite_slug, trace_id, source, category, assertion_type, assertion_value, description, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(caseId, slug, trace.id, "trace", result.evalCase.category, result.evalCase.assertion.type, assertionValue, result.evalCase.description, now);
+    suite.cases.push({
+      id: caseId,
+      suiteSlug: slug,
+      traceId: trace.id,
+      source: "trace",
+      category: result.evalCase.category,
+      assertion: result.evalCase.assertion,
+      description: result.evalCase.description
+    });
+  }
+  if (suite.cases.length > MAX_EVAL_CASES) {
+    const toRemove = suite.cases.slice(0, suite.cases.length - MAX_EVAL_CASES);
+    for (const c of toRemove) {
+      db.prepare("DELETE FROM eval_cases WHERE id = ?").run(c.id);
+    }
+    suite.cases = suite.cases.slice(suite.cases.length - MAX_EVAL_CASES);
+  }
+  db.prepare("UPDATE eval_suites SET version = version + 1, updated_at = ? WHERE slug = ?").run(now, slug);
+  suite.version++;
+  return { suite, llmCalls: totalLLMCalls };
+}
+async function validateJudges(db, slug, apiKey, skillContent, simulationModel) {
+  const suite = getEvalSuite(db, slug);
+  if (!suite || suite.cases.length === 0) {
+    return { tpr: void 0, tnr: void 0, sampleSize: 0 };
+  }
+  const corrections = getTraces(db, slug, { kind: "correction" });
+  const simulationOptions = simulationModel ? { model: simulationModel, cache: /* @__PURE__ */ new Map() } : void 0;
+  let truePositives = 0;
+  for (const trace of corrections) {
+    const badContent = JSON.stringify(trace.toolResponse);
+    let anyFailed = false;
+    for (const evalCase of suite.cases) {
+      const result = await runSingleCase(badContent, evalCase, apiKey, simulationOptions);
+      if (!result.passed) {
+        anyFailed = true;
+        break;
+      }
+    }
+    if (anyFailed) truePositives++;
+  }
+  let tnr;
+  if (skillContent) {
+    let allPassed = true;
+    for (const evalCase of suite.cases) {
+      const result = await runSingleCase(skillContent, evalCase, apiKey, simulationOptions);
+      if (!result.passed) {
+        allPassed = false;
+        break;
+      }
+    }
+    tnr = allPassed ? 1 : 0;
+  }
+  const tpr = corrections.length > 0 ? truePositives / corrections.length : void 0;
+  const sampleSize = corrections.length + (skillContent ? 1 : 0);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    "UPDATE eval_suites SET tpr = ?, tnr = ?, validation_sample_size = ?, validated_at = ? WHERE slug = ?"
+  ).run(tpr ?? null, tnr ?? null, sampleSize, now, slug);
+  return { tpr, tnr, sampleSize };
+}
+export {
+  generateEvalCase,
+  generateEvalSuite,
+  getEvalSuite,
+  isBehavioralCorrection,
+  shouldGenerateEvals,
+  validateJudges
+};

package/dist/daemon/improver-TGEK6MPE.js

@@ -0,0 +1,186 @@
+import {
+  findRegistryEntry,
+  upsertRegistryEntry
+} from "./chunk-HEYFAUHL.js";
+import {
+  readConfig
+} from "./chunk-545XA5CB.js";
+import "./chunk-MLKGABMK.js";
+
+// src/daemon/improver.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync, appendFileSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+var ANTHROPIC_API_URL = "https://api.anthropic.com/v1/messages";
+var IMPROVEMENT_MODEL = "claude-haiku-4-5-20251001";
+var isDemo = process.env.CAIK_DEMO === "1";
+var MIN_OBSERVATIONS = isDemo ? 1 : 5;
+var MIN_CORRECTION_RATE = isDemo ? 0 : 0.3;
+var MIN_LENGTH_RATIO = 0.5;
+var MAX_LENGTH_RATIO = 2;
+function getLogPath() {
+  return join(homedir(), ".caik", "improvement.log");
+}
+function log(message) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
+`;
+  try {
+    const logPath = getLogPath();
+    const dir = dirname(logPath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    appendFileSync(logPath, line, "utf-8");
+  } catch {
+  }
+}
+function getAnthropicApiKey() {
+  if (process.env.ANTHROPIC_API_KEY) return process.env.ANTHROPIC_API_KEY;
+  try {
+    const configPath = join(homedir(), ".caik", "config.json");
+    if (existsSync(configPath)) {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (typeof raw.anthropicApiKey === "string") return raw.anthropicApiKey;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function stripPii(content) {
+  const home = homedir();
+  return content.replaceAll(home, "~/...");
+}
+function computeStats(observations) {
+  const total = observations.length;
+  const corrections = observations.filter((o) => o.correctionType !== void 0);
+  const correctionRate = total > 0 ? corrections.length / total : 0;
+  const correctionCounts = {};
+  for (const o of corrections) {
+    const t = o.correctionType;
+    correctionCounts[t] = (correctionCounts[t] ?? 0) + 1;
+  }
+  return { total, correctionRate, correctionCounts };
+}
+async function callAnthropic(apiKey, currentContent, stats) {
+  const correctionSummary = Object.entries(stats.correctionCounts).sort(([, a], [, b]) => b - a).map(([type, count]) => `- ${type}: ${count} occurrences`).join("\n");
+  const userMessage = `Here is the current artifact content:
+
+<skill>
+${currentContent}
+</skill>
+
+Observation summary:
+- Total observations: ${stats.total}
+- Correction rate: ${(stats.correctionRate * 100).toFixed(1)}%
+- Correction types:
+${correctionSummary}
+
+Improve this artifact to reduce the correction rate. Focus on the most frequent correction types.`;
+  const body = JSON.stringify({
+    model: IMPROVEMENT_MODEL,
+    max_tokens: 4096,
+    system: "You are improving a Claude Code artifact based on observed failure patterns. Make minimal, targeted changes. Preserve the artifact's core purpose and structure. Return ONLY the improved content, no explanation.",
+    messages: [{ role: "user", content: userMessage }]
+  });
+  const res = await fetch(ANTHROPIC_API_URL, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+      "content-type": "application/json"
+    },
+    body
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Anthropic API ${res.status}: ${text}`);
+  }
+  const data = await res.json();
+  const textBlock = data.content.find((b) => b.type === "text");
+  if (!textBlock?.text) throw new Error("No text in Anthropic response");
+  return textBlock.text;
+}
+function versionOldContent(slug, content) {
+  const dir = join(homedir(), ".caik", "versions", slug);
+  mkdirSync(dir, { recursive: true });
+  const filename = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-") + ".md";
+  writeFileSync(join(dir, filename), content, "utf-8");
+}
+function reportContribution(slug, improvementType, stats, improvedContent) {
+  const config = readConfig();
+  const level = config.contributionLevel ?? "contributor";
+  if (level === "none") return;
+  const apiUrl = config.apiUrl ?? "https://www.caik.dev";
+  const apiKey = config.apiKey;
+  let payload = { slug, improved: true, type: improvementType };
+  if (level === "contributor" || level === "collective") {
+    payload.correctionDistribution = stats.correctionCounts;
+    payload.correctionRate = stats.correctionRate;
+  }
+  if (level === "collective" && improvedContent) {
+    payload.improvedContent = stripPii(improvedContent);
+  }
+  fetch(`${apiUrl}/api/v1/improvements`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...apiKey ? { authorization: `Bearer ${apiKey}` } : {}
+    },
+    body: JSON.stringify(payload)
+  }).catch((err) => {
+    log(`Contribution report failed: ${err instanceof Error ? err.message : String(err)}`);
+  });
+}
+async function runImprovement(slug, observations) {
+  try {
+    const entry = findRegistryEntry(slug);
+    if (!entry) {
+      return { slug, improved: false, error: "Not found in registry" };
+    }
+    const skillPath = entry.files[0];
+    if (!skillPath || !existsSync(skillPath)) {
+      return { slug, improved: false, error: "Skill file not found" };
+    }
+    const currentContent = readFileSync(skillPath, "utf-8");
+    const slugObs = observations.filter((o) => o.slug === slug);
+    const stats = computeStats(slugObs);
+    if (stats.total < MIN_OBSERVATIONS || stats.correctionRate < MIN_CORRECTION_RATE) {
+      return { slug, improved: false };
+    }
+    const apiKey = getAnthropicApiKey();
+    if (!apiKey) {
+      log(`No Anthropic API key available for improvement of ${slug}`);
+      return { slug, improved: false, error: "No API key" };
+    }
+    const improvedContent = await callAnthropic(apiKey, currentContent, stats);
+    const ratio = improvedContent.length / currentContent.length;
+    if (ratio < MIN_LENGTH_RATIO || ratio > MAX_LENGTH_RATIO) {
+      log(`Rejected improvement for ${slug}: length ratio ${ratio.toFixed(2)} out of bounds`);
+      return { slug, improved: false, error: `Length ratio ${ratio.toFixed(2)} out of bounds` };
+    }
+    versionOldContent(slug, currentContent);
+    const proposedPath = skillPath.replace(/SKILL\.md$/, "SKILL.proposed.md");
+    writeFileSync(proposedPath, improvedContent, "utf-8");
+    const topCorrection = Object.entries(stats.correctionCounts).sort(([, a], [, b]) => b - a)[0]?.[0] ?? "general";
+    const improvementType = `correction_fix:${topCorrection}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updatedEntry = {
+      ...entry,
+      updatedAt: now,
+      pendingImprovement: true,
+      improvementLog: [
+        ...entry.improvementLog ?? [],
+        { ts: now, type: improvementType }
+      ]
+    };
+    upsertRegistryEntry(updatedEntry);
+    reportContribution(slug, improvementType, stats, improvedContent);
+    log(`Proposed improvement for ${slug}: ${improvementType}`);
+    return { slug, improved: true, improvementType };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log(`Improvement failed for ${slug}: ${message}`);
+    return { slug, improved: false, error: message };
+  }
+}
+export {
+  runImprovement
+};

package/dist/daemon/llm-FUJ2TBYT.js

@@ -0,0 +1,11 @@
+import {
+  callAnthropic,
+  getAnthropicApiKey,
+  parseLLMJson
+} from "./chunk-SM2FSXIP.js";
+import "./chunk-MLKGABMK.js";
+export {
+  callAnthropic,
+  getAnthropicApiKey,
+  parseLLMJson
+};

package/dist/daemon/nudge-detector-NFRHWZY6.js

@@ -0,0 +1,140 @@
+import "./chunk-MLKGABMK.js";
+
+// src/daemon/nudge-detector.ts
+import { readFileSync, writeFileSync, readdirSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var NUDGE_PATH = join(homedir(), ".caik", "contribution-nudges.json");
+var AGENT_PRIMITIVES = /* @__PURE__ */ new Set([
+  "Read",
+  "Write",
+  "Edit",
+  "Bash",
+  "Grep",
+  "Glob",
+  "Agent",
+  "ToolSearch",
+  "WebFetch",
+  "WebSearch",
+  "NotebookEdit",
+  "TaskCreate",
+  "TaskUpdate",
+  "TaskGet",
+  "TaskList",
+  "TaskOutput",
+  "TaskStop",
+  "Skill",
+  "SendMessage",
+  "EnterPlanMode",
+  "ExitPlanMode",
+  "AskUserQuestion",
+  "EnterWorktree",
+  "ExitWorktree"
+]);
+var MIN_USES = 10;
+var MIN_SESSIONS = 3;
+var MIN_SUCCESS_RATE = 0.8;
+var MAX_NUDGES = 3;
+var DEDUP_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
+function isCaikTool(tool) {
+  return tool.startsWith("mcp__caik__") || tool.startsWith("mcp__caik-dev__") || tool.startsWith("caik");
+}
+function extractDisplayName(tool) {
+  if (tool.startsWith("mcp__")) {
+    const parts = tool.split("__");
+    return parts[1] ?? tool;
+  }
+  return tool;
+}
+function detectContributionNudges(observationsDir, registrySlugs) {
+  if (!existsSync(observationsDir)) return [];
+  let files;
+  try {
+    files = readdirSync(observationsDir).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return [];
+  }
+  const toolStats = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const filePath = join(observationsDir, file);
+    let lines;
+    try {
+      const content = readFileSync(filePath, "utf-8").trim();
+      if (!content) continue;
+      lines = content.split("\n").filter(Boolean);
+    } catch {
+      continue;
+    }
+    for (const line of lines) {
+      let obs;
+      try {
+        obs = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const tool = obs.tool;
+      if (!tool) continue;
+      if (AGENT_PRIMITIVES.has(tool)) continue;
+      if (isCaikTool(tool)) continue;
+      if (registrySlugs.has(obs.slug)) continue;
+      let stats = toolStats.get(tool);
+      if (!stats) {
+        stats = { tool, uses: 0, sessions: /* @__PURE__ */ new Set(), successes: 0, lastUsed: obs.timestamp };
+        toolStats.set(tool, stats);
+      }
+      stats.uses++;
+      if (obs.sessionId) stats.sessions.add(obs.sessionId);
+      if (obs.success) stats.successes++;
+      if (obs.timestamp > stats.lastUsed) stats.lastUsed = obs.timestamp;
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const candidates = [];
+  for (const stats of toolStats.values()) {
+    if (stats.uses < MIN_USES) continue;
+    if (stats.sessions.size < MIN_SESSIONS) continue;
+    const successRate = stats.uses > 0 ? stats.successes / stats.uses : 0;
+    if (successRate < MIN_SUCCESS_RATE) continue;
+    const isMcp = stats.tool.startsWith("mcp__");
+    candidates.push({
+      type: isMcp ? "share_mcp_server" : "share_skill",
+      toolName: stats.tool,
+      displayName: extractDisplayName(stats.tool),
+      uses: stats.uses,
+      sessions: stats.sessions.size,
+      successRate: Math.round(successRate * 100) / 100,
+      lastUsed: stats.lastUsed,
+      createdAt: now
+    });
+  }
+  candidates.sort((a, b) => b.uses - a.uses);
+  return candidates.slice(0, MAX_NUDGES);
+}
+function readNudgeFile() {
+  try {
+    return JSON.parse(readFileSync(NUDGE_PATH, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function writeNudgeFile(nudges) {
+  const sevenDaysAgo = new Date(Date.now() - DEDUP_WINDOW_MS).toISOString();
+  const existing = readNudgeFile();
+  const recentlyNudged = new Set(
+    existing.filter((n) => n.createdAt > sevenDaysAgo).map((n) => n.toolName)
+  );
+  const newNudges = nudges.filter((n) => !recentlyNudged.has(n.toolName));
+  if (newNudges.length === 0) return;
+  const merged = [
+    ...existing.filter((n) => n.createdAt > sevenDaysAgo),
+    ...newNudges
+  ].slice(0, 5);
+  const dir = join(homedir(), ".caik");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
+  writeFileSync(NUDGE_PATH, JSON.stringify(merged, null, 2), "utf-8");
+}
+export {
+  detectContributionNudges,
+  readNudgeFile,
+  writeNudgeFile
+};