@bcelep/capint 0.4.2

package/src/lib/doctor.js

@@ -0,0 +1,115 @@
+const fs = require("fs");
+const path = require("path");
+const { loadMatrix } = require("./route-engine");
+const { validateExecutionIntent } = require("./contract");
+
+function loadRegistry(rootDir) {
+  const p = path.join(rootDir, "registry.json");
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf-8"));
+  } catch (e) {
+    return { parseError: e.message };
+  }
+}
+
+function skillsOnDisk(rootDir) {
+  const skillsDir = path.join(rootDir, "skills");
+  if (!fs.existsSync(skillsDir)) return [];
+  return fs
+    .readdirSync(skillsDir)
+    .filter((n) => fs.existsSync(path.join(skillsDir, n, "SKILL.md")));
+}
+
+function runDoctor(rootDir) {
+  const issues = [];
+  const warnings = [];
+  const ok = [];
+
+  const matrix = loadMatrix(rootDir);
+  if (!matrix) issues.push("skill-routing-matrix.json missing or invalid");
+  else ok.push(`matrix schema_version ${matrix.schema_version}`);
+
+  const registry = loadRegistry(rootDir);
+  if (!registry) issues.push("registry.json missing or invalid");
+  else if (registry.parseError) issues.push(`registry.json parse error: ${registry.parseError}`);
+  else ok.push("registry.json valid");
+
+  if (matrix && registry && !registry.parseError) {
+    const disk = new Set(skillsOnDisk(rootDir));
+    const allReg = new Set([
+      ...(registry.core || []),
+      ...(registry.recommended || []),
+      ...(registry.optional || []),
+      ...(registry.project_added || [])
+    ]);
+    for (const name of registry.core || []) {
+      if (!disk.has(name)) warnings.push(`core skill missing on disk: ${name}`);
+    }
+    for (const tt of matrix.task_types || []) {
+      for (const s of tt.skills || []) {
+        if (!allReg.has(s) && !disk.has(s)) {
+          warnings.push(`task_type ${tt.id} references skill not in registry: ${s}`);
+        }
+      }
+    }
+    const ids = matrix.task_types.map((t) => t.id);
+    if (new Set(ids).size !== ids.length) issues.push("duplicate task_type ids in matrix");
+  }
+
+  if (!fs.existsSync(path.join(rootDir, "AGENT.md"))) {
+    warnings.push("AGENT.md missing — run capint init");
+  }
+
+  const policy = matrix?.provider_activation_policy;
+  if (policy) {
+    ok.push("provider_activation_policy present (default off)");
+  } else {
+    warnings.push("provider_activation_policy missing — memory/graph always local fallback");
+  }
+
+  const pass = issues.length === 0;
+  return {
+    pass,
+    exit_code: pass ? 0 : 1,
+    issues,
+    warnings,
+    ok,
+    auto_fix: false,
+    hint: pass ? "No auto-fix performed (by design)." : "Resolve issues manually; doctor does not mutate files."
+  };
+}
+
+function runStatus(rootDir) {
+  const matrix = loadMatrix(rootDir);
+  const registry = loadRegistry(rootDir);
+  const doctor = runDoctor(rootDir);
+  const contextPath = path.join(rootDir, ".capint", "context.json");
+  let context = null;
+  if (fs.existsSync(contextPath)) {
+    try {
+      context = JSON.parse(fs.readFileSync(contextPath, "utf-8"));
+    } catch {
+      context = { error: "invalid json" };
+    }
+  }
+
+  return {
+    capint_package: require(path.join(__dirname, "..", "..", "package.json")).version,
+    matrix_version: matrix?.schema_version || null,
+    matrix_updated: matrix?.updated_at || null,
+    registry_schema: registry?.schema_version || null,
+    skills_on_disk: skillsOnDisk(rootDir).length,
+    core_skills: (registry?.core || []).length,
+    doctor_pass: doctor.pass,
+    provider_defaults: {
+      memory: matrix?.provider_activation_policy?.memory_providers?.default || "off",
+      graph: matrix?.provider_activation_policy?.graph_providers?.default || "off"
+    },
+    context,
+    warnings_count: doctor.warnings.length,
+    issues_count: doctor.issues.length
+  };
+}
+
+module.exports = { runDoctor, runStatus, skillsOnDisk, loadRegistry };

package/src/lib/event-log.js

@@ -0,0 +1,40 @@
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+const LOG_DIR = ".capint/logs";
+const LOG_FILE = "route-events.ndjson";
+
+function eventLogEnabled(rootDir) {
+  if (process.env.CAPINT_EVENT_LOG === "1") return true;
+  const ctxPath = path.join(rootDir, ".capint", "context.json");
+  if (!fs.existsSync(ctxPath)) return false;
+  try {
+    const ctx = JSON.parse(fs.readFileSync(ctxPath, "utf-8"));
+    return Boolean(ctx.event_log);
+  } catch {
+    return false;
+  }
+}
+
+function appendRouteEvents(rootDir, events) {
+  if (!rootDir || !Array.isArray(events) || events.length === 0) return { written: false };
+  if (!eventLogEnabled(rootDir)) return { written: false, reason: "disabled" };
+
+  const dir = path.join(rootDir, LOG_DIR);
+  const file = path.join(dir, LOG_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+  const ts = new Date().toISOString();
+  const lines = events.map((e) =>
+    JSON.stringify({
+      event_id: crypto.randomUUID(),
+      ts,
+      ...e
+    })
+  );
+  fs.appendFileSync(file, `${lines.join("\n")}\n`, "utf-8");
+  return { written: true, path: path.join(LOG_DIR, LOG_FILE), count: events.length };
+}
+
+module.exports = { appendRouteEvents, eventLogEnabled, LOG_DIR, LOG_FILE };

package/src/lib/execution-policy.js

@@ -0,0 +1,168 @@
+const fs = require("fs");
+const path = require("path");
+const { resolveOrchestration } = require("./orchestration");
+
+function resolveInstallationStatus(routeResult, rootDir) {
+  const winner = routeResult.winner;
+  if (!winner) {
+    return { resolution_status: "installed", resolution_hint: null };
+  }
+
+  if (winner.type === "skill") {
+    const allSkills = routeResult.rows.flatMap((r) => r.skills);
+    const match = allSkills.find((s) => s.name === winner.resource);
+    if (match?.status === "not_installed") {
+      return {
+        resolution_status: "not_installed",
+        resolution_hint: `Skill "${winner.resource}" not installed — run capint init or add skills/${winner.resource}/SKILL.md`
+      };
+    }
+  }
+
+  if (winner.type === "workflow" && rootDir) {
+    const wfPath = path.join(rootDir, "workflows", `${winner.resource}.md`);
+    if (!fs.existsSync(wfPath)) {
+      return {
+        resolution_status: "not_installed",
+        resolution_hint: `Workflow "${winner.resource}" missing — run capint init to copy skill bundle`
+      };
+    }
+  }
+
+  return { resolution_status: "installed", resolution_hint: null };
+}
+
+function buildConfirmBlock(text, overallWeight, matrix) {
+  const policy = matrix?.clarification_policy || {};
+  const mode = policy.mode || "adaptive";
+  const shouldAsk = mode === "always_confirm" || overallWeight !== "light";
+  if (!shouldAsk) return { enabled: false, mode, prompt: null, options: [], default_option: null };
+
+  const options = [
+    { id: "apply_now", label: "Apply now" },
+    { id: "plan_first", label: "Show short plan first" },
+    { id: "analyze_only", label: "Analyze only, no code" }
+  ];
+  const maxOptions = Math.max(1, Math.min(policy.max_options || 3, options.length));
+  const shortened = options.slice(0, maxOptions);
+  const defaultOption = policy.default_option || (overallWeight === "light" ? "apply_now" : "plan_first");
+  return {
+    enabled: true,
+    mode,
+    prompt: `How should I proceed? (${text.slice(0, 80)}${text.length > 80 ? "..." : ""})`,
+    options: shortened,
+    default_option: shortened.some((o) => o.id === defaultOption) ? defaultOption : shortened[0].id
+  };
+}
+
+function buildVerificationHints(overallWeight, primaryTaskType, matrix) {
+  const defaults = matrix?.verification_defaults || {};
+  const profile = primaryTaskType?.verification_profile || defaults.profile || "standard";
+  const taskRequires = Boolean(primaryTaskType?.verification_required);
+
+  if (overallWeight === "light" && !defaults.require_on_light && !taskRequires) {
+    return { required: false, hints: [], profile };
+  }
+
+  const hints = [];
+  hints.push("Run a targeted test or lint command before claiming done");
+  if (profile === "security") {
+    hints.push("Verify auth/session paths and no secret leakage");
+  } else if (profile === "debug") {
+    hints.push("Reproduce bug, apply fix, re-run failing case");
+  } else if (profile === "refactor") {
+    hints.push("Existing tests pass; no behavior change unless intended");
+  }
+
+  const required =
+    overallWeight === "heavy" ||
+    overallWeight === "medium" ||
+    Boolean(primaryTaskType?.verification_required);
+
+  return { required, hints, profile };
+}
+
+function buildRouteExplain(routeResult, parsedIntent, matrix) {
+  const primary = routeResult.taskTypeResolved;
+  return {
+    matched_task_type: primary?.id || null,
+    resolver_order: matrix?.resolver_order || [],
+    winner: routeResult.winner
+      ? { name: routeResult.winner.name, resource: routeResult.winner.resource, confidence: routeResult.confidence }
+      : null,
+    overrides: parsedIntent?.overrides || {},
+    overall_weight: routeResult.overall
+  };
+}
+
+function buildExecutionPolicy({ rawText, routeResult, memoryStrategy, matrix, parsedIntent, rootDir }) {
+  const primaryTaskType = routeResult.taskTypeResolved;
+  const rows = routeResult.rows;
+  const overallWeight = routeResult.overall;
+  const fallbackCapability =
+    matrix?.fallback_policy?.ambiguous_default_capability || primaryTaskType?.id || "vague_request";
+  const capability = primaryTaskType?.capability || fallbackCapability;
+  const installStatus = resolveInstallationStatus(routeResult, rootDir);
+  let plan =
+    primaryTaskType?.default_execution_policy ||
+    matrix?.execution_policy_defaults?.[overallWeight] ||
+    (overallWeight === "light" ? "auto" : "confirm");
+  if (installStatus.resolution_status === "not_installed") {
+    plan = "confirm";
+  }
+  const confirmBlock = buildConfirmBlock(rawText, overallWeight, matrix);
+  const ambiguous = rows.some((r) => r.reason.includes("ambiguous default"));
+  const verification = buildVerificationHints(overallWeight, primaryTaskType, matrix);
+  const orchestration = resolveOrchestration(primaryTaskType, confirmBlock.default_option, matrix);
+
+  const out = {
+    intent: rawText,
+    capability,
+    resolution: `${routeResult.winner.name}/${routeResult.winner.resource}`,
+    memory: memoryStrategy?.memory || primaryTaskType?.requires_memory || "optional",
+    plan,
+    confirm: confirmBlock,
+    confirm_question: confirmBlock.prompt,
+    confirm_options: confirmBlock.options,
+    confirm_default_option: confirmBlock.default_option,
+    fallback: ambiguous ? { capability, override: matrix?.fallback_policy?.override_hint || "/workflow" } : null,
+    verification_required: verification.required,
+    verification_hints: verification.hints,
+    verification_profile: verification.profile,
+    provider_activation: memoryStrategy?.provider_activation || null,
+    context_pack: memoryStrategy?.context_pack || null,
+    orchestration,
+    route_explain: buildRouteExplain(routeResult, parsedIntent, matrix),
+    resolution_status: installStatus.resolution_status,
+    resolution_hint: installStatus.resolution_hint
+  };
+
+  if (memoryStrategy?.local_adapters) {
+    out.local_adapters = memoryStrategy.local_adapters;
+  }
+
+  if (confirmBlock.default_option === "analyze_only" && verification.required) {
+    out.verification_hints = [
+      ...verification.hints,
+      "analyze_only: produce evidence-backed findings without code edits"
+    ];
+  }
+
+  if (installStatus.resolution_status === "not_installed") {
+    out.verification_required = true;
+    out.verification_hints = [
+      ...(out.verification_hints || []),
+      "install skill bundle or add SKILL.md before apply"
+    ];
+  }
+
+  return out;
+}
+
+module.exports = {
+  buildExecutionPolicy,
+  buildConfirmBlock,
+  buildVerificationHints,
+  buildRouteExplain,
+  resolveInstallationStatus
+};

package/src/lib/ide-sync.js

@@ -0,0 +1,277 @@
+/**
+ * IDE projection sync — capint/projections/session-start.md → native IDE entry files.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const DEFAULT_TARGETS = ["cursor", "claude", "gemini", "antigravity"];
+
+const CAPINT_SYNC_MARKER =
+  "<!-- source: capint/projections/session-start.md | capint ide sync -->";
+
+function pkgRoot() {
+  return path.join(__dirname, "..", "..");
+}
+
+function readSessionStart() {
+  const p = path.join(pkgRoot(), "projections", "session-start.md");
+  if (!fs.existsSync(p)) return null;
+  return fs.readFileSync(p, "utf-8");
+}
+
+function stripFrontmatter(text) {
+  if (!text.startsWith("---")) return text;
+  const end = text.indexOf("---", 3);
+  if (end === -1) return text;
+  return text.slice(end + 3).trimStart();
+}
+
+function syncCursorRule(cwd, body, dryRun) {
+  const dir = path.join(cwd, ".cursor", "rules");
+  const file = path.join(dir, "00-capint-session.mdc");
+  const content = `---
+description: CapInt session start + Execution Intent (always apply)
+alwaysApply: true
+---
+
+${CAPINT_SYNC_MARKER}
+
+${body}
+`;
+  if (!dryRun) {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, content);
+  }
+  return file;
+}
+
+function syncClaudeMd(cwd, body, dryRun) {
+  const file = path.join(cwd, "CLAUDE.md");
+  const content = `${CAPINT_SYNC_MARKER}
+
+# Claude Code — CapInt
+
+Read root **AGENT.md** for project rules.
+
+${body}
+`;
+  if (!dryRun) fs.writeFileSync(file, content);
+  return file;
+}
+
+function syncGeminiMd(cwd, body, dryRun) {
+  const file = path.join(cwd, "GEMINI.md");
+  const content = `${CAPINT_SYNC_MARKER}
+
+# Gemini — CapInt
+
+Read root **AGENT.md** for project rules.
+
+${body}
+`;
+  if (!dryRun) fs.writeFileSync(file, content);
+  return file;
+}
+
+function syncAntigravity(cwd, body, dryRun) {
+  const written = [];
+  const agentsDir = path.join(cwd, ".agents");
+  const rulesDir = path.join(agentsDir, "rules");
+  const skillsDir = path.join(agentsDir, "skills", "capint-router");
+
+  const sessionBody = stripFrontmatter(body);
+  const sessionFile = path.join(rulesDir, "00-capint-session.md");
+  const indexFile = path.join(agentsDir, "CAPINT.md");
+  const routerSkill = path.join(skillsDir, "SKILL.md");
+
+  const sessionContent = `${CAPINT_SYNC_MARKER}
+
+# CapInt session + task routing
+
+${sessionBody}
+`;
+  const indexContent = `${CAPINT_SYNC_MARKER}
+
+# CapInt
+
+Canonical project files: \`AGENT.md\`, \`.capint/\` — run \`capint ide sync\` after init.
+`;
+  const routerContent = `---
+name: capint-router
+description: Routes agent to CapInt session protocol and skill-routing-matrix.json.
+origin: capint
+capint_bundle: antigravity-projection
+---
+
+# CapInt Router (Antigravity)
+
+1. Session: \`.agents/rules/00-capint-session.md\` + \`AGENT.md\`
+2. Task routing: \`capint route "your task"\`
+3. Skills: \`skills/<name>/SKILL.md\`
+
+Index: \`.agents/CAPINT.md\`
+`;
+
+  if (!dryRun) {
+    fs.mkdirSync(rulesDir, { recursive: true });
+    fs.mkdirSync(skillsDir, { recursive: true });
+    fs.writeFileSync(sessionFile, sessionContent);
+    fs.writeFileSync(indexFile, indexContent);
+    fs.writeFileSync(routerSkill, routerContent);
+  }
+
+  written.push(sessionFile, indexFile, routerSkill);
+  return written;
+}
+
+function updateContextJson(cwd, targets, dryRun) {
+  const file = path.join(cwd, ".capint", "context.json");
+  if (!fs.existsSync(file)) return null;
+  let ctx;
+  try {
+    ctx = JSON.parse(fs.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+  ctx.ide_projection = {
+    targets: [...targets],
+    last_synced: new Date().toISOString().slice(0, 10),
+    canonical: "capint/projections/session-start.md",
+    marker: CAPINT_SYNC_MARKER
+  };
+  if (!dryRun) fs.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}\n`);
+  return file;
+}
+
+function syncIdeProjections(cwd, options = {}) {
+  const { targets = DEFAULT_TARGETS, dryRun = false } = options;
+  const result = { written: [], skipped: [], errors: [] };
+
+  const capintDir = path.join(cwd, ".capint");
+  if (!fs.existsSync(capintDir) && !fs.existsSync(path.join(cwd, "AGENT.md"))) {
+    result.errors.push("No CapInt project — run capint init first");
+    return result;
+  }
+
+  const raw = readSessionStart();
+  if (!raw) {
+    result.errors.push("session-start.md not found in package projections/");
+    return result;
+  }
+  const body = stripFrontmatter(raw);
+  const set = new Set(targets.map((t) => t.toLowerCase()));
+
+  if (set.has("cursor")) result.written.push(syncCursorRule(cwd, body, dryRun));
+  if (set.has("claude") || set.has("claude-code")) {
+    result.written.push(syncClaudeMd(cwd, body, dryRun));
+  }
+  if (set.has("gemini") || set.has("gemini-cli")) {
+    result.written.push(syncGeminiMd(cwd, body, dryRun));
+  }
+  if (set.has("codex")) {
+    result.skipped.push("codex uses root AGENTS.md — ensure AGENTS.md exists");
+  }
+  if (set.has("antigravity")) {
+    result.written.push(...syncAntigravity(cwd, body, dryRun));
+  }
+
+  const ctxPath = updateContextJson(cwd, [...set], dryRun);
+  if (ctxPath) result.written.push(ctxPath);
+
+  return result;
+}
+
+function checkIdeProjection(cwd) {
+  const marker = CAPINT_SYNC_MARKER;
+  function hasMarker(filePath) {
+    if (!fs.existsSync(filePath)) return false;
+    return fs.readFileSync(filePath, "utf-8").includes(marker);
+  }
+
+  return [
+    {
+      name: "Cursor .mdc",
+      ok: hasMarker(path.join(cwd, ".cursor", "rules", "00-capint-session.mdc")),
+      path: ".cursor/rules/00-capint-session.mdc"
+    },
+    { name: "CLAUDE.md", ok: hasMarker(path.join(cwd, "CLAUDE.md")), path: "CLAUDE.md" },
+    { name: "GEMINI.md", ok: hasMarker(path.join(cwd, "GEMINI.md")), path: "GEMINI.md" },
+    {
+      name: "Antigravity session",
+      ok: hasMarker(path.join(cwd, ".agents", "rules", "00-capint-session.md")),
+      path: ".agents/rules/00-capint-session.md"
+    },
+    {
+      name: "AGENTS.md",
+      ok: fs.existsSync(path.join(cwd, "AGENTS.md")),
+      path: "AGENTS.md"
+    },
+    {
+      name: "skill-routing-matrix.json",
+      ok: fs.existsSync(path.join(cwd, "skill-routing-matrix.json")),
+      path: "skill-routing-matrix.json"
+    }
+  ];
+}
+
+function appendIdeManifestEntries(rootDir, syncResult, dryRun) {
+  if (dryRun) return null;
+  const { readScaffoldManifest, writeScaffoldManifest } = require("./scaffold/manifest");
+  const { enrichFileEntry } = require("./scaffold/manifest-schema");
+
+  const manifestPath = path.join(rootDir, ".capint", "scaffold-manifest.json");
+  if (!fs.existsSync(manifestPath)) return null;
+
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return null;
+  }
+
+  const existing = new Set((manifest.files || []).map((f) => f.path));
+  const relPaths = syncResult.written.map((abs) =>
+    path.relative(rootDir, abs).replace(/\\/g, "/")
+  );
+
+  for (const rel of relPaths) {
+    if (existing.has(rel)) continue;
+    manifest.files.push(
+      enrichFileEntry({
+        path: rel,
+        action: "created",
+        source: "capint",
+        removable: true,
+        kind: "ide_projection",
+        marker: CAPINT_SYNC_MARKER
+      })
+    );
+  }
+
+  manifest.last_run = new Date().toISOString();
+  const report = {
+    generated_at: manifest.last_run,
+    preset: manifest.preset,
+    summary: manifest.summary,
+    results: manifest.files.map((f) => ({
+      path: f.path,
+      action: f.action,
+      source: f.source,
+      removable: f.removable,
+      kind: f.kind,
+      marker: f.marker,
+      sidecar: f.sidecar
+    }))
+  };
+  writeScaffoldManifest(rootDir, report);
+  return manifestPath;
+}
+
+module.exports = {
+  DEFAULT_TARGETS,
+  CAPINT_SYNC_MARKER,
+  syncIdeProjections,
+  checkIdeProjection,
+  appendIdeManifestEntries
+};