caik-cli 0.1.1 → 0.6.0

package/dist/daemon/registry-FI4GTO3H.js

@@ -0,0 +1,20 @@
+import {
+  cleanupFiles,
+  findRegistryEntry,
+  listRegistryEntries,
+  readRegistry,
+  removeRegistryEntry,
+  upsertRegistryEntry,
+  writeRegistry
+} from "./chunk-HEYFAUHL.js";
+import "./chunk-545XA5CB.js";
+import "./chunk-MLKGABMK.js";
+export {
+  cleanupFiles,
+  findRegistryEntry,
+  listRegistryEntries,
+  readRegistry,
+  removeRegistryEntry,
+  upsertRegistryEntry,
+  writeRegistry
+};

package/dist/daemon/server.js

@@ -0,0 +1,356 @@
+import {
+  getDb
+} from "./chunk-OD5NUFH2.js";
+import "./chunk-MLKGABMK.js";
+
+// src/daemon/server.ts
+import { createServer } from "http";
+import {
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  appendFileSync,
+  existsSync,
+  unlinkSync
+} from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CAIK_DIR = join(homedir(), ".caik");
+var PID_PATH = join(CAIK_DIR, "daemon.pid");
+var LOG_PATH = join(CAIK_DIR, "daemon.log");
+var OBS_DIR = join(CAIK_DIR, "observations");
+var PORT = parseInt(process.env.CAIK_DAEMON_PORT ?? "37778", 10);
+var IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
+function ensureDirs() {
+  if (!existsSync(CAIK_DIR)) mkdirSync(CAIK_DIR, { recursive: true, mode: 448 });
+  if (!existsSync(OBS_DIR)) mkdirSync(OBS_DIR, { recursive: true, mode: 448 });
+}
+function log(msg) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`;
+  try {
+    appendFileSync(LOG_PATH, line, "utf-8");
+  } catch {
+  }
+}
+var sessions = /* @__PURE__ */ new Map();
+var totalObservationCount = 0;
+var startTime = Date.now();
+function appendObservation(obs) {
+  const filePath = join(OBS_DIR, `${obs.slug}.jsonl`);
+  try {
+    appendFileSync(filePath, JSON.stringify(obs) + "\n", "utf-8");
+  } catch {
+    log(`Failed to write observation for slug=${obs.slug}`);
+  }
+}
+function insertObservation(obs) {
+  try {
+    const db = getDb();
+    db.prepare(`
+      INSERT INTO observations (session_id, slug, tool, success, platform, correction_type, correction_source, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      obs.sessionId,
+      obs.slug,
+      obs.tool,
+      obs.success ? 1 : 0,
+      obs.platform ?? null,
+      obs.correctionType ?? null,
+      obs.correctionSource ?? null,
+      obs.timestamp
+    );
+  } catch (err) {
+    log(`insertObservation failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function cleanupOldObservations() {
+  try {
+    const db = getDb();
+    db.prepare("DELETE FROM observations WHERE created_at < datetime('now', '-30 days')").run();
+  } catch {
+  }
+}
+function readObservationsForSlug(slug) {
+  const filePath = join(OBS_DIR, `${slug}.jsonl`);
+  if (!existsSync(filePath)) return [];
+  try {
+    const lines = readFileSync(filePath, "utf-8").trim().split("\n").filter(Boolean);
+    return lines.map((l) => JSON.parse(l));
+  } catch {
+    return [];
+  }
+}
+async function runImprovementCycle(sessionId) {
+  const observations = sessions.get(sessionId) ?? [];
+  const result = { improved: [], skipped: [] };
+  const slugs = new Set(observations.map((o) => o.slug));
+  const isDemo = process.env.CAIK_DEMO === "1";
+  const minObs = isDemo ? 1 : 5;
+  const minRate = isDemo ? 0 : 0.3;
+  for (const slug of slugs) {
+    const allObs = readObservationsForSlug(slug);
+    const corrections = allObs.filter((o) => o.correctionType);
+    const correctionRate = allObs.length > 0 ? corrections.length / allObs.length : 0;
+    if (allObs.length < minObs || correctionRate <= minRate) {
+      result.skipped.push(slug);
+      continue;
+    }
+    try {
+      let usedAutoResearch = false;
+      try {
+        const { getDb: getDb2 } = await import("./db-QEXVVTAL.js");
+        const { getEvalSuite, shouldGenerateEvals, generateEvalSuite, validateJudges } = await import("./eval-generator-OR2FAYLB.js");
+        const { autoResearchLoop, shouldAutoApply, applyImprovement, proposeImprovement } = await import("./autoresearch-2MAEM2YI.js");
+        const { getAnthropicApiKey } = await import("./llm-FUJ2TBYT.js");
+        const { readConfig } = await import("./config-F7HE3JRY.js");
+        const { findRegistryEntry } = await import("./registry-FI4GTO3H.js");
+        const config = readConfig();
+        const arSettings = config.autoResearch ?? {};
+        if (arSettings.enabled === false) throw new Error("AutoResearch disabled");
+        const apiKey = getAnthropicApiKey();
+        if (!apiKey) throw new Error("No API key");
+        const db = getDb2();
+        const entry = findRegistryEntry(slug);
+        const skillPath = entry?.files[0];
+        if (!entry || !skillPath || !existsSync(skillPath)) throw new Error("Skill file not found");
+        const skillContent = readFileSync(skillPath, "utf-8");
+        if (shouldGenerateEvals(db, slug)) {
+          await generateEvalSuite(db, slug, apiKey, arSettings.mutationModel);
+          await validateJudges(db, slug, apiKey, skillContent, arSettings.mutationModel);
+        }
+        const suite = getEvalSuite(db, slug);
+        if (suite && suite.tpr !== void 0 && suite.tpr > 0.7 && (suite.tnr === void 0 || suite.tnr > 0.7) && suite.cases.length >= 3) {
+          if (!isDemo && entry.lastImprovedAt) {
+            const hoursSince = (Date.now() - new Date(entry.lastImprovedAt).getTime()) / 36e5;
+            if (hoursSince < 24) {
+              result.skipped.push(slug);
+              continue;
+            }
+          }
+          const loopConfig = {
+            maxIterations: arSettings.maxIterations ?? 5,
+            mutationsPerIteration: arSettings.mutationsPerIteration ?? 3,
+            maxLLMCalls: arSettings.maxLLMCalls ?? 30,
+            mutationModel: arSettings.mutationModel ?? "claude-haiku-4-5-20251001"
+          };
+          const loopResult = await autoResearchLoop(slug, skillPath, suite, loopConfig, apiKey);
+          if (loopResult.bestContent) {
+            const mode = arSettings.mode ?? "autonomous";
+            if (shouldAutoApply(mode, loopResult)) {
+              applyImprovement(slug, skillPath, loopResult.bestContent, loopResult, db);
+              log(`AutoResearch auto-applied for slug=${slug} (${loopResult.baselineScore.passRate} -> ${loopResult.bestScore.passRate})`);
+            } else {
+              proposeImprovement(slug, skillPath, loopResult.bestContent, loopResult, db);
+              log(`AutoResearch proposed for slug=${slug} (${loopResult.baselineScore.passRate} -> ${loopResult.bestScore.passRate})`);
+            }
+            result.improved.push(slug);
+            usedAutoResearch = true;
+          } else {
+            log(`AutoResearch: no improvement found for slug=${slug}`);
+          }
+        }
+      } catch (arErr) {
+        log(`AutoResearch unavailable for slug=${slug}: ${arErr instanceof Error ? arErr.message : String(arErr)}`);
+      }
+      if (!usedAutoResearch) {
+        const improver = await import("./improver-TGEK6MPE.js");
+        await improver.runImprovement(slug, allObs);
+        result.improved.push(slug);
+        log(`One-shot improvement triggered for slug=${slug} (${allObs.length} obs, ${(correctionRate * 100).toFixed(0)}% correction rate)`);
+      }
+    } catch (err) {
+      log(`Improvement failed for slug=${slug}: ${err instanceof Error ? err.message : String(err)}`);
+      result.skipped.push(slug);
+    }
+  }
+  sessions.delete(sessionId);
+  return result;
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+function json(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(body)
+  });
+  res.end(body);
+}
+function notFound(res) {
+  json(res, 404, { error: "not found" });
+}
+function badRequest(res, message) {
+  json(res, 400, { error: message });
+}
+async function handleRequest(req, res) {
+  const url = new URL(req.url ?? "/", `http://localhost:${PORT}`);
+  const path = url.pathname;
+  const method = req.method ?? "GET";
+  if (method === "GET" && path === "/health") {
+    json(res, 200, {
+      status: "ok",
+      uptime: Math.floor((Date.now() - startTime) / 1e3),
+      observationCount: totalObservationCount,
+      pid: process.pid
+    });
+    return;
+  }
+  if (method === "POST" && path === "/observations") {
+    let body;
+    try {
+      const raw = await readBody(req);
+      body = JSON.parse(raw);
+    } catch {
+      badRequest(res, "invalid JSON body");
+      return;
+    }
+    if (!body.sessionId || !body.slug || !body.tool) {
+      badRequest(res, "missing required fields: sessionId, slug, tool");
+      return;
+    }
+    if (!body.timestamp) {
+      body.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    if (!sessions.has(body.sessionId)) {
+      sessions.set(body.sessionId, []);
+    }
+    sessions.get(body.sessionId).push(body);
+    totalObservationCount++;
+    appendObservation(body);
+    insertObservation(body);
+    json(res, 200, { ok: true, count: totalObservationCount });
+    return;
+  }
+  const sessionEndMatch = path.match(/^\/sessions\/([^/]+)\/end$/);
+  if (method === "POST" && sessionEndMatch) {
+    const sessionId = decodeURIComponent(sessionEndMatch[1]);
+    log(`Session end: ${sessionId}`);
+    const result = await runImprovementCycle(sessionId);
+    try {
+      const { detectContributionNudges, writeNudgeFile } = await import("./nudge-detector-NFRHWZY6.js");
+      const { listRegistryEntries } = await import("./platform-7N3LQDIB.js");
+      const entries = listRegistryEntries();
+      const registrySlugs = new Set(entries.map((e) => e.slug));
+      const nudges = detectContributionNudges(OBS_DIR, registrySlugs);
+      if (nudges.length > 0) {
+        writeNudgeFile(nudges);
+        log(`Contribution nudges: ${nudges.length} detected (${nudges.map((n) => n.displayName).join(", ")})`);
+      }
+    } catch {
+    }
+    json(res, 200, result);
+    return;
+  }
+  const statusMatch = path.match(/^\/status\/([^/]+)$/);
+  if (method === "GET" && statusMatch) {
+    const slug = decodeURIComponent(statusMatch[1]);
+    const observations = readObservationsForSlug(slug);
+    const corrections = observations.filter((o) => o.correctionType);
+    json(res, 200, {
+      slug,
+      totalObservations: observations.length,
+      corrections: corrections.length,
+      correctionRate: observations.length > 0 ? Math.round(corrections.length / observations.length * 100) : 0,
+      lastObservation: observations.length > 0 ? observations[observations.length - 1].timestamp : null
+    });
+    return;
+  }
+  const arStatusMatch = path.match(/^\/autoresearch\/status\/([^/]+)$/);
+  if (method === "GET" && arStatusMatch) {
+    try {
+      const slug = decodeURIComponent(arStatusMatch[1]);
+      const { getDb: getDb2 } = await import("./db-QEXVVTAL.js");
+      const db = getDb2();
+      const row = db.prepare(
+        "SELECT * FROM loop_results WHERE slug = ? ORDER BY created_at DESC LIMIT 1"
+      ).get(slug);
+      json(res, 200, row ?? { slug, message: "No autoresearch runs yet" });
+    } catch (err) {
+      json(res, 200, { error: err instanceof Error ? err.message : String(err) });
+    }
+    return;
+  }
+  const evalsMatch = path.match(/^\/evals\/([^/]+)$/);
+  if (method === "GET" && evalsMatch) {
+    try {
+      const slug = decodeURIComponent(evalsMatch[1]);
+      const { getDb: getDb2 } = await import("./db-QEXVVTAL.js");
+      const { getEvalSuite } = await import("./eval-generator-OR2FAYLB.js");
+      const suite = getEvalSuite(getDb2(), slug);
+      json(res, 200, suite ?? { slug, message: "No eval suite" });
+    } catch (err) {
+      json(res, 200, { error: err instanceof Error ? err.message : String(err) });
+    }
+    return;
+  }
+  const tracesCountMatch = path.match(/^\/traces\/([^/]+)\/count$/);
+  if (method === "GET" && tracesCountMatch) {
+    try {
+      const slug = decodeURIComponent(tracesCountMatch[1]);
+      const { getDb: getDb2 } = await import("./db-QEXVVTAL.js");
+      const { getTraceCount } = await import("./trace-store-T7XFGQSX.js");
+      const counts = getTraceCount(getDb2(), slug);
+      json(res, 200, counts);
+    } catch {
+      json(res, 200, { total: 0, corrections: 0, successes: 0 });
+    }
+    return;
+  }
+  notFound(res);
+}
+var idleTimer = null;
+function resetIdleTimer() {
+  if (idleTimer) clearTimeout(idleTimer);
+  idleTimer = setTimeout(() => {
+    log("Shutting down due to inactivity");
+    shutdown();
+  }, IDLE_TIMEOUT_MS);
+}
+function writePidFile() {
+  ensureDirs();
+  writeFileSync(PID_PATH, String(process.pid), "utf-8");
+}
+function removePidFile() {
+  try {
+    if (existsSync(PID_PATH)) unlinkSync(PID_PATH);
+  } catch {
+  }
+}
+function shutdown() {
+  log("Daemon shutting down");
+  removePidFile();
+  server.close(() => {
+    process.exit(0);
+  });
+  setTimeout(() => process.exit(0), 5e3).unref();
+}
+var server = createServer((req, res) => {
+  resetIdleTimer();
+  handleRequest(req, res).catch((err) => {
+    log(`Request error: ${err instanceof Error ? err.message : String(err)}`);
+    json(res, 500, { error: "internal server error" });
+  });
+});
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+ensureDirs();
+writePidFile();
+cleanupOldObservations();
+try {
+  const db = getDb();
+  const check = db.prepare("SELECT count(*) as cnt FROM observations").get();
+  log(`Observations table: ${check.cnt} rows at startup`);
+} catch (err) {
+  log(`Observations table check failed: ${err instanceof Error ? err.message : String(err)}`);
+}
+server.listen(PORT, "127.0.0.1", () => {
+  log(`Daemon started on port ${PORT} (pid=${process.pid})`);
+  resetIdleTimer();
+});

package/dist/daemon/trace-store-T7XFGQSX.js

@@ -0,0 +1,19 @@
+import {
+  bufferPrompt,
+  bufferToolCall,
+  buildTraces,
+  clearSessionBuffer,
+  getTraceCount,
+  getTraces,
+  persistTraces
+} from "./chunk-NJICGNCK.js";
+import "./chunk-MLKGABMK.js";
+export {
+  bufferPrompt,
+  bufferToolCall,
+  buildTraces,
+  clearSessionBuffer,
+  getTraceCount,
+  getTraces,
+  persistTraces
+};

package/dist/daemon-UXYMG46V.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import "./chunk-ZLRN7Q7C.js";
+
+// src/daemon/manager.ts
+import { spawn } from "child_process";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+var DAEMON_PORT = parseInt(process.env.CAIK_DAEMON_PORT ?? "37778", 10);
+var CAIK_DIR = join(homedir(), ".caik");
+var PID_PATH = join(CAIK_DIR, "daemon.pid");
+var HEALTH_URL = `http://127.0.0.1:${DAEMON_PORT}/health`;
+async function healthCheck() {
+  try {
+    const res = await fetch(HEALTH_URL, { signal: AbortSignal.timeout(2e3) });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function ensureDaemonRunning() {
+  const existing = await healthCheck();
+  if (existing) return true;
+  const thisFile = fileURLToPath(import.meta.url);
+  const serverPath = join(thisFile, "..", "daemon", "server.js");
+  const child = spawn(process.execPath, [serverPath], {
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore"],
+    env: { ...process.env, CAIK_DAEMON_PORT: String(DAEMON_PORT) }
+  });
+  child.unref();
+  for (let i = 0; i < 6; i++) {
+    await sleep(500);
+    const health = await healthCheck();
+    if (health) return true;
+  }
+  return false;
+}
+async function stopDaemon() {
+  let pid = null;
+  try {
+    if (existsSync(PID_PATH)) {
+      pid = parseInt(readFileSync(PID_PATH, "utf-8").trim(), 10);
+    }
+  } catch {
+  }
+  if (!pid || isNaN(pid)) return;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  for (let i = 0; i < 10; i++) {
+    await sleep(500);
+    try {
+      process.kill(pid, 0);
+    } catch {
+      return;
+    }
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+}
+async function getDaemonStatus() {
+  const health = await healthCheck();
+  if (!health) return { running: false };
+  return {
+    running: true,
+    uptime: health.uptime,
+    observationCount: health.observationCount
+  };
+}
+export {
+  DAEMON_PORT,
+  ensureDaemonRunning,
+  getDaemonStatus,
+  stopDaemon
+};

package/dist/db-TLNRIXLK.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import {
+  closeDb,
+  getDb,
+  getDefaultDbPath,
+  initSchema,
+  init_db,
+  openDb
+} from "./chunk-H2ZKCXMJ.js";
+import "./chunk-ZLRN7Q7C.js";
+init_db();
+export {
+  closeDb,
+  getDb,
+  getDefaultDbPath,
+  initSchema,
+  openDb
+};

package/dist/eval-generator-GGMRPO3K.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import {
+  generateEvalCase,
+  generateEvalSuite,
+  getEvalSuite,
+  isBehavioralCorrection,
+  shouldGenerateEvals,
+  validateJudges
+} from "./chunk-5MHNQAV4.js";
+import "./chunk-7AIZTHHZ.js";
+import "./chunk-D4IM3YRX.js";
+import "./chunk-DJJHS7KK.js";
+import "./chunk-ZLRN7Q7C.js";
+export {
+  generateEvalCase,
+  generateEvalSuite,
+  getEvalSuite,
+  isBehavioralCorrection,
+  shouldGenerateEvals,
+  validateJudges
+};

package/dist/eval-runner-EF4K6T5Y.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import {
+  checkCodeAssertion,
+  checkPatternAssertion,
+  runEvalSuite,
+  runSingleCase
+} from "./chunk-D4IM3YRX.js";
+import "./chunk-DJJHS7KK.js";
+import "./chunk-ZLRN7Q7C.js";
+export {
+  checkCodeAssertion,
+  checkPatternAssertion,
+  runEvalSuite,
+  runSingleCase
+};