caik-cli 0.1.1 → 0.6.0

package/dist/daemon/autoresearch-2MAEM2YI.js

@@ -0,0 +1,272 @@
+import {
+  runEvalSuite
+} from "./chunk-UMDJFPN6.js";
+import {
+  callAnthropic
+} from "./chunk-SM2FSXIP.js";
+import {
+  findRegistryEntry,
+  upsertRegistryEntry
+} from "./chunk-HEYFAUHL.js";
+import "./chunk-545XA5CB.js";
+import "./chunk-MLKGABMK.js";
+
+// src/daemon/autoresearch.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
+var STRATEGY_DESCRIPTIONS = {
+  targeted_fix: "Fix the specific failing eval cases while preserving passing behavior.",
+  simplify: "Simplify the skill instructions while maintaining the same behavior.",
+  restructure: "Restructure the skill for clarity and completeness.",
+  scope_narrow: "Narrow the scope \u2014 be more specific about what the skill does and doesn't do.",
+  format_refine: "Add explicit format specifications for output structure."
+};
+function selectStrategies(suite, failedCaseIds) {
+  const strategies = ["targeted_fix"];
+  if (failedCaseIds.length === 0) return strategies;
+  const failedCases = suite.cases.filter((c) => failedCaseIds.includes(c.id));
+  const failedCategories = failedCases.map((c) => c.category.toLowerCase());
+  const failRate = failedCaseIds.length / Math.max(suite.cases.length, 1);
+  if (failedCategories.some((c) => c.includes("scope"))) {
+    strategies.push("scope_narrow");
+  }
+  if (failedCategories.some((c) => c.includes("format"))) {
+    strategies.push("format_refine");
+  }
+  if (failRate <= 0.3) {
+    strategies.push("simplify");
+  }
+  const uniqueCategories = new Set(failedCategories);
+  if (failRate > 0.5 && uniqueCategories.size >= 2) {
+    strategies.push("restructure");
+  }
+  return [...new Set(strategies)];
+}
+function shouldAutoApply(mode, result) {
+  if (mode === "manual") return false;
+  if (!result.bestContent) return false;
+  if (mode === "assisted") {
+    return result.bestScore.passRate === 1 && result.bestScore.lengthRatio >= 0.7 && result.bestScore.lengthRatio <= 1.5;
+  }
+  if (mode === "autonomous") {
+    return result.bestScore.passRate > result.baselineScore.passRate;
+  }
+  return false;
+}
+var MUTATION_SYSTEM = `You are improving a Claude Code artifact. You will be given the current content, the specific eval cases it fails, and context from the correction traces that generated those cases. Make targeted changes to pass the failing cases while preserving behavior for passing cases. Return ONLY the improved content, no explanation or commentary.`;
+async function generateMutations(currentContent, suite, failedCaseIds, strategies, apiKey, model) {
+  const failedCases = suite.cases.filter((c) => failedCaseIds.includes(c.id));
+  const mutations = [];
+  let llmCalls = 0;
+  const failedCaseSummary = failedCases.map((c) => `- [${c.category}] ${c.description} (${c.assertion.type})`).join("\n");
+  const passingCases = suite.cases.filter((c) => !failedCaseIds.includes(c.id));
+  const passingCaseSummary = passingCases.length > 0 ? passingCases.map((c) => `- [${c.category}] ${c.description}`).join("\n") : "(none)";
+  for (const strategy of strategies) {
+    const userMessage = `Current artifact content:
+<skill>
+${currentContent}
+</skill>
+
+Failing eval cases (${failedCaseIds.length}/${suite.cases.length}) \u2014 FIX THESE:
+${failedCaseSummary}
+
+Passing eval cases (${passingCases.length}/${suite.cases.length}) \u2014 PRESERVE THESE:
+${passingCaseSummary}
+
+Strategy: ${strategy} \u2014 ${STRATEGY_DESCRIPTIONS[strategy] ?? "Improve the skill."}
+
+Rewrite the skill to pass the failing cases while keeping the passing cases passing.`;
+    try {
+      const result = await callAnthropic(apiKey, {
+        model,
+        system: MUTATION_SYSTEM,
+        userMessage,
+        maxTokens: 4096
+      });
+      llmCalls++;
+      let content = result.text.trim();
+      content = content.replace(/^<skill>\s*/i, "").replace(/\s*<\/skill>\s*$/i, "");
+      const ratio = content.length / currentContent.length;
+      if (ratio >= 0.3 && ratio <= 3 && content.length > 10) {
+        mutations.push({ content, strategy });
+      }
+    } catch {
+    }
+  }
+  return { mutations, llmCalls };
+}
+async function autoResearchLoop(slug, skillPath, suite, config, apiKey) {
+  const startTime = Date.now();
+  let totalLLMCalls = 0;
+  const usedStrategies = [];
+  const currentContent = readFileSync(skillPath, "utf-8");
+  const baselineScore = await runEvalSuite(currentContent, suite, currentContent, apiKey, config.mutationModel);
+  let best = currentContent;
+  let bestScore = baselineScore;
+  for (let iteration = 0; iteration < config.maxIterations; iteration++) {
+    if (totalLLMCalls >= config.maxLLMCalls) break;
+    const strategies = selectStrategies(suite, bestScore.failedCaseIds).slice(
+      0,
+      config.mutationsPerIteration
+    );
+    const { mutations, llmCalls } = await generateMutations(
+      best,
+      suite,
+      bestScore.failedCaseIds,
+      strategies,
+      apiKey,
+      config.mutationModel
+    );
+    totalLLMCalls += llmCalls;
+    let improved = false;
+    for (const mutation of mutations) {
+      if (totalLLMCalls >= config.maxLLMCalls) break;
+      const score = await runEvalSuite(mutation.content, suite, currentContent, apiKey, config.mutationModel);
+      if (score.passRate > bestScore.passRate) {
+        best = mutation.content;
+        bestScore = score;
+        improved = true;
+        if (!usedStrategies.includes(mutation.strategy)) {
+          usedStrategies.push(mutation.strategy);
+        }
+      }
+    }
+    if (bestScore.passRate === 1) break;
+    if (!improved) break;
+  }
+  const duration = Date.now() - startTime;
+  return {
+    bestContent: best !== currentContent ? best : null,
+    baselineScore,
+    bestScore,
+    iterations: Math.min(config.maxIterations, totalLLMCalls),
+    totalLLMCalls,
+    strategies: usedStrategies,
+    duration
+  };
+}
+function applyImprovement(slug, skillPath, improvedContent, result, db) {
+  const entry = findRegistryEntry(slug);
+  if (!entry) return;
+  const versionsDir = join(homedir(), ".caik", "versions", slug);
+  mkdirSync(versionsDir, { recursive: true });
+  const versionFile = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-") + ".md";
+  writeFileSync(join(versionsDir, versionFile), readFileSync(skillPath, "utf-8"), "utf-8");
+  writeFileSync(skillPath, improvedContent, "utf-8");
+  const obsPath = join(homedir(), ".caik", "observations", `${slug}.jsonl`);
+  if (existsSync(obsPath)) {
+    writeFileSync(obsPath, "", "utf-8");
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedEntry = {
+    ...entry,
+    updatedAt: now,
+    lastImprovedAt: now,
+    localVersion: (entry.localVersion ?? 0) + 1,
+    pendingImprovement: false,
+    lastAutoAppliedAt: now,
+    preApplyCorrectionRate: result.baselineScore.passRate,
+    improvementLog: [
+      ...entry.improvementLog ?? [],
+      { ts: now, type: `autoresearch:${result.strategies.join("+")}` }
+    ],
+    lastLoopResult: {
+      score: result.bestScore.passRate,
+      iterations: result.iterations,
+      timestamp: now
+    }
+  };
+  upsertRegistryEntry(updatedEntry);
+  db.prepare(
+    `INSERT INTO loop_results (id, slug, baseline_pass_rate, best_pass_rate, baseline_pass_count, best_pass_count,
+     total_cases, iterations, total_llm_calls, duration_ms, strategies, best_content, applied, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?)`
+  ).run(
+    randomUUID(),
+    slug,
+    result.baselineScore.passRate,
+    result.bestScore.passRate,
+    result.baselineScore.passCount,
+    result.bestScore.passCount,
+    result.bestScore.totalCases,
+    result.iterations,
+    result.totalLLMCalls,
+    result.duration,
+    JSON.stringify(result.strategies),
+    improvedContent,
+    now
+  );
+}
+function proposeImprovement(slug, skillPath, improvedContent, result, db) {
+  const entry = findRegistryEntry(slug);
+  if (!entry) return;
+  const currentContent = readFileSync(skillPath, "utf-8");
+  const versionsDir = join(homedir(), ".caik", "versions", slug);
+  mkdirSync(versionsDir, { recursive: true });
+  const versionFile = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-") + ".md";
+  writeFileSync(join(versionsDir, versionFile), currentContent, "utf-8");
+  const proposedPath = skillPath.endsWith("SKILL.md") ? skillPath.replace(/SKILL\.md$/, "SKILL.proposed.md") : `${skillPath}.proposed`;
+  writeFileSync(proposedPath, improvedContent, "utf-8");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedEntry = {
+    ...entry,
+    updatedAt: now,
+    pendingImprovement: true,
+    improvementLog: [
+      ...entry.improvementLog ?? [],
+      { ts: now, type: `autoresearch:${result.strategies.join("+")}` }
+    ],
+    lastLoopResult: {
+      score: result.bestScore.passRate,
+      iterations: result.iterations,
+      timestamp: now
+    }
+  };
+  upsertRegistryEntry(updatedEntry);
+  db.prepare(
+    `INSERT INTO loop_results (id, slug, baseline_pass_rate, best_pass_rate, baseline_pass_count, best_pass_count,
+     total_cases, iterations, total_llm_calls, duration_ms, strategies, best_content, applied, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?)`
+  ).run(
+    randomUUID(),
+    slug,
+    result.baselineScore.passRate,
+    result.bestScore.passRate,
+    result.baselineScore.passCount,
+    result.bestScore.passCount,
+    result.bestScore.totalCases,
+    result.iterations,
+    result.totalLLMCalls,
+    result.duration,
+    JSON.stringify(result.strategies),
+    improvedContent,
+    now
+  );
+}
+function checkWatchdog(slug, entry, observations) {
+  if (!entry.lastAutoAppliedAt) return { shouldRollback: false };
+  const postApply = observations.filter(
+    (o) => new Date(o.timestamp) > new Date(entry.lastAutoAppliedAt)
+  );
+  if (postApply.length < 10) return { shouldRollback: false };
+  const postCorrectionRate = postApply.filter((o) => o.correctionType).length / postApply.length;
+  const preCorrectionRate = entry.preApplyCorrectionRate ?? 0;
+  if (postCorrectionRate - preCorrectionRate > 0.2) {
+    return {
+      shouldRollback: true,
+      reason: `Correction rate increased from ${(preCorrectionRate * 100).toFixed(0)}% to ${(postCorrectionRate * 100).toFixed(0)}%`
+    };
+  }
+  return { shouldRollback: false };
+}
+export {
+  applyImprovement,
+  autoResearchLoop,
+  checkWatchdog,
+  generateMutations,
+  proposeImprovement,
+  selectStrategies,
+  shouldAutoApply
+};

package/dist/daemon/chunk-545XA5CB.js

@@ -0,0 +1,77 @@
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, chmodSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONTRIBUTION_LEVELS = [
+  { value: "none", name: "None", description: "Nothing sent. Directory access only." },
+  { value: "minimal", name: "Minimal", description: "Install/uninstall + engagement + retention. Basic recommendations." },
+  { value: "contributor", name: "Contributor", description: "Error/success signals + co-installs. Full recommendations. (default)" },
+  { value: "collective", name: "Collective", description: "Stack context + session shape + workflow patterns. Proactive recommendations + leaderboard." }
+];
+var DEFAULT_CONFIG = {
+  apiUrl: "https://www.caik.dev",
+  defaultLimit: 10,
+  version: 1
+};
+function getConfigDir() {
+  return join(homedir(), ".caik");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function readConfig() {
+  const path = getConfigPath();
+  if (!existsSync(path)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { ...DEFAULT_CONFIG, ...parsed };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function writeConfig(config) {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  const path = getConfigPath();
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  chmodSync(path, 384);
+}
+function getOrCreateInstallationId() {
+  const config = readConfig();
+  if (config.installationId) return config.installationId;
+  const id = `inst_${globalThis.crypto.randomUUID().replace(/-/g, "").slice(0, 16)}`;
+  writeConfig({ ...config, installationId: id });
+  return id;
+}
+function getApiKey() {
+  return process.env.CAIK_API_KEY ?? readConfig().apiKey;
+}
+function setApiKey(key) {
+  const config = readConfig();
+  config.apiKey = key;
+  writeConfig(config);
+}
+function resolveConfig(opts) {
+  const config = readConfig();
+  return {
+    apiUrl: opts.apiUrl ?? process.env.CAIK_API_URL ?? config.apiUrl ?? DEFAULT_CONFIG.apiUrl,
+    apiKey: opts.apiKey ?? process.env.CAIK_API_KEY ?? config.apiKey
+  };
+}
+
+export {
+  CONTRIBUTION_LEVELS,
+  getConfigDir,
+  getConfigPath,
+  readConfig,
+  writeConfig,
+  getOrCreateInstallationId,
+  getApiKey,
+  setApiKey,
+  resolveConfig
+};

package/dist/daemon/chunk-HEYFAUHL.js

@@ -0,0 +1,90 @@
+import {
+  getConfigDir
+} from "./chunk-545XA5CB.js";
+
+// src/platform/registry.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from "fs";
+import { join } from "path";
+var REGISTRY_VERSION = 1;
+function getRegistryPath() {
+  return join(getConfigDir(), "registry.json");
+}
+function emptyRegistry() {
+  return { version: REGISTRY_VERSION, entries: [] };
+}
+function readRegistry() {
+  const path = getRegistryPath();
+  if (!existsSync(path)) return emptyRegistry();
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.entries || !Array.isArray(parsed.entries)) return emptyRegistry();
+    return parsed;
+  } catch {
+    return emptyRegistry();
+  }
+}
+function writeRegistry(registry) {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  const path = getRegistryPath();
+  writeFileSync(path, JSON.stringify(registry, null, 2) + "\n", "utf-8");
+}
+function upsertRegistryEntry(entry) {
+  const registry = readRegistry();
+  const idx = registry.entries.findIndex(
+    (e) => e.slug === entry.slug && e.platform === entry.platform
+  );
+  if (idx >= 0) {
+    registry.entries[idx] = entry;
+  } else {
+    registry.entries.push(entry);
+  }
+  writeRegistry(registry);
+}
+function removeRegistryEntry(slug, platform) {
+  const registry = readRegistry();
+  const idx = registry.entries.findIndex(
+    (e) => e.slug === slug && e.platform === platform
+  );
+  if (idx < 0) return null;
+  const [removed] = registry.entries.splice(idx, 1);
+  writeRegistry(registry);
+  return removed;
+}
+function findRegistryEntry(slug, platform) {
+  const registry = readRegistry();
+  return registry.entries.find(
+    (e) => e.slug === slug && (!platform || e.platform === platform)
+  ) ?? null;
+}
+function listRegistryEntries(platform) {
+  const registry = readRegistry();
+  if (!platform) return registry.entries;
+  return registry.entries.filter((e) => e.platform === platform);
+}
+function cleanupFiles(entry) {
+  const failed = [];
+  for (const file of entry.files) {
+    try {
+      if (existsSync(file)) {
+        unlinkSync(file);
+      }
+    } catch {
+      failed.push(file);
+    }
+  }
+  return failed;
+}
+
+export {
+  readRegistry,
+  writeRegistry,
+  upsertRegistryEntry,
+  removeRegistryEntry,
+  findRegistryEntry,
+  listRegistryEntries,
+  cleanupFiles
+};

package/dist/daemon/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/daemon/chunk-NJICGNCK.js

@@ -0,0 +1,150 @@
+// src/daemon/trace-store.ts
+import { randomUUID } from "crypto";
+function bufferToolCall(db, sessionId, toolName, toolInput, toolResponse, success, slug) {
+  db.prepare(
+    `INSERT INTO session_buffer (session_id, type, timestamp, tool_name, tool_input, tool_response, success, slug)
+     VALUES (?, 'tool_call', ?, ?, ?, ?, ?, ?)`
+  ).run(
+    sessionId,
+    (/* @__PURE__ */ new Date()).toISOString(),
+    toolName,
+    JSON.stringify(toolInput),
+    JSON.stringify(toolResponse),
+    success ? 1 : 0,
+    slug
+  );
+}
+function bufferPrompt(db, sessionId, prompt, correctionType, slug) {
+  const type = correctionType ? "correction" : "prompt";
+  db.prepare(
+    `INSERT INTO session_buffer (session_id, type, timestamp, prompt, correction_type, slug)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(sessionId, type, (/* @__PURE__ */ new Date()).toISOString(), prompt, correctionType ?? null, slug ?? null);
+}
+function buildTraces(db, sessionId) {
+  const rows = db.prepare("SELECT * FROM session_buffer WHERE session_id = ? ORDER BY id ASC").all(sessionId);
+  const traces = [];
+  const lastToolCall = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.type === "tool_call" && row.slug) {
+      lastToolCall.set(row.slug, row);
+    }
+    if (row.type === "correction" && row.correction_type) {
+      const slug = row.slug ?? "unknown";
+      const toolCall = lastToolCall.get(slug);
+      traces.push({
+        id: randomUUID(),
+        sessionId,
+        slug,
+        timestamp: row.timestamp,
+        kind: "correction",
+        toolName: toolCall?.tool_name ?? "unknown",
+        toolInput: toolCall?.tool_input ? JSON.parse(toolCall.tool_input) : {},
+        toolResponse: toolCall?.tool_response ? JSON.parse(toolCall.tool_response) : {},
+        correctionType: row.correction_type,
+        correctionPrompt: row.prompt ?? void 0
+      });
+    }
+  }
+  const successfulCalls = rows.filter(
+    (r) => r.type === "tool_call" && r.success === 1 && r.slug
+  );
+  for (const row of successfulCalls) {
+    if (Math.random() < 0.2) {
+      traces.push({
+        id: randomUUID(),
+        sessionId,
+        slug: row.slug,
+        timestamp: row.timestamp,
+        kind: "success",
+        toolName: row.tool_name ?? "unknown",
+        toolInput: row.tool_input ? JSON.parse(row.tool_input) : {},
+        toolResponse: row.tool_response ? JSON.parse(row.tool_response) : {}
+      });
+    }
+  }
+  return traces;
+}
+function persistTraces(db, traces) {
+  const stmt = db.prepare(
+    `INSERT INTO traces (id, session_id, slug, timestamp, kind, tool_name, tool_input, tool_response,
+     correction_type, correction_prompt, skill_content_hash, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  const insertMany = db.transaction((items) => {
+    for (const t of items) {
+      stmt.run(
+        t.id,
+        t.sessionId,
+        t.slug,
+        t.timestamp,
+        t.kind,
+        t.toolName,
+        JSON.stringify(t.toolInput),
+        JSON.stringify(t.toolResponse),
+        t.correctionType ?? null,
+        t.correctionPrompt ?? null,
+        t.skillContentHash ?? null,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+    }
+  });
+  insertMany(traces);
+}
+function rowToTrace(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    slug: row.slug,
+    timestamp: row.timestamp,
+    kind: row.kind,
+    toolName: row.tool_name,
+    toolInput: row.tool_input ? JSON.parse(row.tool_input) : {},
+    toolResponse: row.tool_response ? JSON.parse(row.tool_response) : {},
+    correctionType: row.correction_type ?? void 0,
+    correctionPrompt: row.correction_prompt ?? void 0,
+    skillContentHash: row.skill_content_hash ?? void 0
+  };
+}
+function getTraces(db, slug, opts) {
+  let sql = "SELECT * FROM traces WHERE slug = ?";
+  const params = [slug];
+  if (opts?.kind) {
+    sql += " AND kind = ?";
+    params.push(opts.kind);
+  }
+  sql += " ORDER BY timestamp DESC";
+  if (opts?.limit) {
+    sql += " LIMIT ?";
+    params.push(opts.limit);
+  }
+  const rows = db.prepare(sql).all(...params);
+  return rows.map(rowToTrace);
+}
+function getTraceCount(db, slug) {
+  const row = db.prepare(
+    `SELECT
+        COUNT(*) as total,
+        SUM(CASE WHEN kind = 'correction' THEN 1 ELSE 0 END) as corrections,
+        SUM(CASE WHEN kind = 'success' THEN 1 ELSE 0 END) as successes
+       FROM traces WHERE slug = ?`
+  ).get(slug);
+  return {
+    total: row.total,
+    corrections: row.corrections ?? 0,
+    successes: row.successes ?? 0
+  };
+}
+function clearSessionBuffer(db, sessionId) {
+  db.prepare("DELETE FROM session_buffer WHERE session_id = ?").run(sessionId);
+}
+
+export {
+  bufferToolCall,
+  bufferPrompt,
+  buildTraces,
+  persistTraces,
+  getTraces,
+  getTraceCount,
+  clearSessionBuffer
+};