@bcelep/capint 0.4.2

package/src/commands/scaffold.js

@@ -0,0 +1,37 @@
+const path = require("path");
+const { runScaffold, PRESET_MANIFEST } = require("../lib/scaffold");
+
+module.exports = async function scaffold(args, flags) {
+  const rootDir = process.cwd();
+  const preset = flags.preset || args.find((a) => !a.startsWith("--")) || "minimal";
+  const projectName = flags.name || path.basename(rootDir);
+  const force = Boolean(flags.force);
+
+  if (flags.list) {
+    console.log("\nAvailable presets:\n");
+    for (const [id, meta] of Object.entries(PRESET_MANIFEST)) {
+      console.log(`  ${id.padEnd(20)} ${meta.description}`);
+    }
+    console.log("");
+    return;
+  }
+
+  const report = runScaffold({ rootDir, preset, projectName, force });
+  if (report.error) {
+    console.error(report.error);
+    process.exit(1);
+  }
+
+  if (flags.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+
+  console.log("\n## CapInt Scaffold\n");
+  console.log(`Preset: ${preset}`);
+  console.log(`Summary: created=${report.summary.created} updated=${report.summary.updated} skipped=${report.summary.skipped} conflict=${report.summary.conflict}\n`);
+  for (const r of report.results) {
+    console.log(`  [${r.action}] ${r.path}${r.sidecar ? ` (sidecar: ${r.sidecar})` : ""}`);
+  }
+  console.log("");
+};

package/src/commands/status.js

@@ -0,0 +1,22 @@
+const { runStatus } = require("../lib/doctor");
+
+module.exports = async function status(_args, flags) {
+  const rootDir = process.cwd();
+  const data = runStatus(rootDir);
+
+  if (flags.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  console.log("\n## CapInt Status (read-only)\n");
+  console.log(`Package: @bcelep/capint v${data.capint_package}`);
+  console.log(`Matrix: ${data.matrix_version || "—"} (${data.matrix_updated || "—"})`);
+  console.log(`Skills on disk: ${data.skills_on_disk} (core registry: ${data.core_skills})`);
+  console.log(`Doctor: ${data.doctor_pass ? "pass" : "fail"} (issues: ${data.issues_count}, warnings: ${data.warnings_count})`);
+  console.log(`Providers default: memory=${data.provider_defaults.memory}, graph=${data.provider_defaults.graph}`);
+  if (data.context) {
+    console.log(`Context preset: ${data.context.preset || "—"}`);
+  }
+  console.log("");
+};

package/src/commands/uninstall.js

@@ -0,0 +1,46 @@
+const path = require("path");
+const { buildUninstallPlan, executeUninstall } = require("../lib/uninstall");
+
+module.exports = async function uninstall(flags = {}) {
+  const rootDir = process.cwd();
+  const dryRun = Boolean(flags["dry-run"]);
+  const keepAgent = Boolean(flags["keep-agent"]);
+  const keepIde = Boolean(flags["keep-ide"]);
+  const includeSidecars = Boolean(flags["include-sidecars"]);
+  const yes = Boolean(flags.yes || flags.y);
+
+  const plan = buildUninstallPlan(rootDir, { keepAgent, keepIde, includeSidecars });
+
+  if (flags.json) {
+    console.log(JSON.stringify({ dry_run: dryRun, plan: plan.map((p) => p.path) }, null, 2));
+    if (dryRun) return;
+  } else {
+    console.log("\n## CapInt Uninstall\n");
+    if (!plan.length) {
+      console.log("Nothing to remove.\n");
+      return;
+    }
+    console.log("Will remove:");
+    for (const p of plan) console.log(`  - ${p.path}`);
+    if (keepAgent) console.log("\nKeeping: AGENT.md, design.md, AGENTS.md (--keep-agent)");
+    if (keepIde) console.log("Keeping: IDE projections (--keep-ide)");
+    console.log("");
+  }
+
+  if (dryRun) {
+    if (!flags.json) console.log("Dry-run — no files deleted.\n");
+    return;
+  }
+
+  if (!yes && !flags.json) {
+    console.error("Add --yes to confirm removal.");
+    process.exit(1);
+  }
+
+  const result = executeUninstall(rootDir, plan, false);
+  if (!flags.json) {
+    for (const p of result.removed) console.log(`  removed ${p}`);
+    for (const p of result.skipped) console.log(`  skipped ${p}`);
+    console.log("\nDone. Global CLI: npm uninstall -g @bcelep/capint\n");
+  }
+};

package/src/commands/upgrade.js

@@ -0,0 +1,69 @@
+const path = require("path");
+const { planUpgrade, applyUpgrade } = require("../lib/upgrade-matrix");
+
+function pkgRoot() {
+  return path.join(__dirname, "..", "..");
+}
+
+module.exports = async function upgrade(flags = {}) {
+  const rootDir = process.cwd();
+  const dryRun = !flags.apply;
+  const plan = planUpgrade(rootDir, pkgRoot());
+
+  if (plan.error) {
+    console.error(plan.error);
+    process.exit(1);
+  }
+
+  if (flags.json) {
+    console.log(
+      JSON.stringify(
+        {
+          dry_run: dryRun,
+          project_schema: plan.project_schema,
+          package_schema: plan.package_schema,
+          conflicts: plan.conflicts,
+          custom_preserved: plan.custom_preserved,
+          summary: plan.summary
+        },
+        null,
+        2
+      )
+    );
+    if (dryRun) return;
+  } else {
+    console.log("\n## CapInt Upgrade (matrix)\n");
+    console.log(`Project schema: ${plan.project_schema}`);
+    console.log(`Package schema: ${plan.package_schema}`);
+    console.log(`\n${plan.summary}\n`);
+
+    if (plan.custom_preserved.length) {
+      console.log("Custom preserved task_types:");
+      for (const id of plan.custom_preserved) console.log(`  + ${id}`);
+      console.log("");
+    }
+
+    if (plan.conflicts.length) {
+      console.log("Conflicts (package wins on --apply):");
+      for (const c of plan.conflicts) {
+        console.log(`  ${c.id}.${c.field}`);
+        console.log(`    project: ${JSON.stringify(c.project_value)}`);
+        console.log(`    package: ${JSON.stringify(c.package_value)}`);
+      }
+      console.log("");
+    } else {
+      console.log("No field conflicts.\n");
+    }
+  }
+
+  if (dryRun) {
+    if (!flags.json) console.log("Dry-run — use --apply to write backup + update matrix.\n");
+    return;
+  }
+
+  const backup = applyUpgrade(rootDir, plan.merged);
+  if (!flags.json) {
+    console.log(`Backup: ${path.relative(rootDir, backup)}`);
+    console.log("Matrix updated.\n");
+  }
+};

package/src/lib/audit.js

@@ -0,0 +1,107 @@
+const fs = require("fs");
+const path = require("path");
+const { runDoctor } = require("./doctor");
+const { loadMatrix } = require("./route-engine");
+
+const EXPECTED_AGENT_MARKERS = ["Execution Intent", "confirm", "parseIntent"];
+
+function fileExists(rootDir, rel) {
+  return fs.existsSync(path.join(rootDir, rel));
+}
+
+function readText(rootDir, rel) {
+  const p = path.join(rootDir, rel);
+  if (!fs.existsSync(p)) return null;
+  return fs.readFileSync(p, "utf-8");
+}
+
+function runAudit(rootDir) {
+  const doctor = runDoctor(rootDir);
+  const matrix = loadMatrix(rootDir);
+  const findings = [];
+  const recommendations = [];
+
+  const agentMd = readText(rootDir, "AGENT.md");
+  const designMd = readText(rootDir, "design.md");
+  const handoffMd = readText(rootDir, "HANDOFF.md");
+  const manifestPath = path.join(rootDir, ".capint", "scaffold-manifest.json");
+
+  if (!agentMd) {
+    findings.push({ level: "warning", code: "missing_agent_md", message: "AGENT.md missing" });
+    recommendations.push("capint init --preset minimal");
+  } else {
+    for (const marker of EXPECTED_AGENT_MARKERS) {
+      if (!agentMd.includes(marker)) {
+        findings.push({
+          level: "info",
+          code: "agent_contract_drift",
+          message: `AGENT.md missing expected marker: ${marker}`
+        });
+      }
+    }
+  }
+
+  if (!designMd) {
+    findings.push({ level: "warning", code: "missing_design_md", message: "design.md missing" });
+    recommendations.push("capint init --preset minimal");
+  }
+
+  if (fileExists(rootDir, ".capint/context.json") && !handoffMd) {
+    findings.push({
+      level: "info",
+      code: "handoff_optional",
+      message: "prismx-compatible context present but HANDOFF.md missing"
+    });
+    recommendations.push("capint scaffold --preset prismx-compatible");
+  }
+
+  if (fs.existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      const conflicts = (manifest.files || []).filter((f) => f.action === "conflict").length;
+      if (conflicts > 0) {
+        findings.push({
+          level: "warning",
+          code: "scaffold_conflicts",
+          message: `${conflicts} scaffold conflict(s) unresolved — review *.capint.new.md files`
+        });
+      }
+    } catch {
+      findings.push({ level: "issue", code: "bad_scaffold_manifest", message: "scaffold-manifest.json invalid JSON" });
+    }
+  }
+
+  if (matrix) {
+    const withoutPattern = (matrix.task_types || []).filter((t) => !t.orchestration_pattern).map((t) => t.id);
+    if (withoutPattern.length) {
+      findings.push({
+        level: "info",
+        code: "matrix_patterns_incomplete",
+        message: `task_types without orchestration_pattern: ${withoutPattern.join(", ")}`
+      });
+    }
+  }
+
+  for (const issue of doctor.issues) {
+    findings.push({ level: "issue", code: "doctor", message: issue });
+  }
+  for (const w of doctor.warnings) {
+    findings.push({ level: "warning", code: "doctor", message: w });
+  }
+
+  const issueCount = findings.filter((f) => f.level === "issue").length;
+  const warningCount = findings.filter((f) => f.level === "warning").length;
+
+  return {
+    mode: "read_only",
+    side_effects: false,
+    pass: issueCount === 0,
+    exit_code: issueCount === 0 ? 0 : 1,
+    summary: { issues: issueCount, warnings: warningCount, info: findings.filter((f) => f.level === "info").length },
+    findings,
+    recommendations: [...new Set(recommendations)],
+    doctor_pass: doctor.pass
+  };
+}
+
+module.exports = { runAudit };

package/src/lib/capability-router.js

@@ -0,0 +1,118 @@
+const WEIGHT_RANK = { light: 0, medium: 1, heavy: 2 };
+const WEIGHT_EMOJI = { light: "🟢", medium: "🟡", heavy: "🔴" };
+
+function applyFileThresholdSignals(classification, matrix) {
+  const estimated = classification?.signals?.estimated_files;
+  if (!estimated || !matrix?.classification?.file_thresholds) return classification;
+  const next = { ...classification, reasons: [...(classification.reasons || [])] };
+  const thresholds = matrix.classification.file_thresholds;
+  if (estimated >= (thresholds.heavy || Number.MAX_SAFE_INTEGER)) {
+    next.reasons.push(`file_threshold:heavy(${estimated})`);
+  } else if (estimated >= (thresholds.medium || Number.MAX_SAFE_INTEGER)) {
+    next.reasons.push(`file_threshold:medium(${estimated})`);
+  } else {
+    next.reasons.push(`file_threshold:light(${estimated})`);
+  }
+  return next;
+}
+
+function skillStatus(name, registry, installed) {
+  if (!installed.includes(name)) return "not_installed";
+  for (const cat of ["core", "recommended", "optional", "project_added"]) {
+    if ((registry[cat] || []).includes(name)) return cat;
+  }
+  return "on_disk";
+}
+
+function collectSkills(text, matrix, classification, matchKeywords) {
+  const skills = new Set();
+  let workflow = null;
+  let rulesHint = null;
+  const order = matrix?.resolver_order || ["exact_keyword", "domain_rules", "classification_default"];
+
+  if (order.includes("exact_keyword") && classification.taskType) {
+    for (const s of classification.taskType.skills || []) skills.add(s);
+    workflow = classification.taskType.workflow || null;
+    rulesHint = classification.taskType.rules_hint || null;
+  }
+
+  if (order.includes("domain_rules")) {
+    for (const tt of matrix.task_types || []) {
+      if (matchKeywords(text, tt.keywords || [])) {
+        for (const s of tt.skills || []) skills.add(s);
+        if (tt.workflow) workflow = tt.workflow;
+        if (tt.rules_hint) rulesHint = tt.rules_hint;
+      }
+    }
+    for (const [ruleFile, meta] of Object.entries(matrix.rules_domain_map || {})) {
+      const domain = ruleFile.replace("rules/", "").replace(".md", "");
+      if (matchKeywords(text, [domain, ...domain.split("-")])) {
+        const minWeight = meta.weight_min || "light";
+        if (WEIGHT_RANK[classification.weight] >= WEIGHT_RANK[minWeight]) {
+          for (const s of meta.skills || []) skills.add(s);
+          rulesHint = rulesHint || ruleFile;
+        }
+      }
+    }
+  }
+
+  if (order.includes("classification_default") && !skills.size) skills.add("capability-router");
+  return { skills: [...skills], workflow, rulesHint };
+}
+
+function deriveProviders(taskType, skills, workflow) {
+  if (taskType?.providers?.length) return taskType.providers;
+  const providers = [];
+  if (workflow) providers.push({ name: "workflow", type: "workflow", resource: workflow.replace(/^\//, ""), confidence_base: 0.8 });
+  if (skills?.length) providers.push({ name: "skill", type: "skill", resource: skills[0], confidence_base: 0.75 });
+  if (!providers.length) providers.push({ name: "fallback", type: "skill", resource: "capability-router", confidence_base: 0.5 });
+  return providers;
+}
+
+function pickProvider(providers, resolverOrder = []) {
+  const sorted = [...providers].sort((a, b) => (b.confidence_base || 0) - (a.confidence_base || 0));
+  if (!resolverOrder.length) return sorted[0];
+  for (const rule of resolverOrder) {
+    if (rule === "exact_keyword") {
+      const s = sorted.find((p) => p.type === "skill");
+      if (s) return s;
+    }
+    if (rule === "domain_rules") {
+      const w = sorted.find((p) => p.type === "workflow");
+      if (w) return w;
+    }
+    if (rule === "classification_default") return sorted[0];
+  }
+  return sorted[0];
+}
+
+function routeCapability(parsedIntent, matrix, registry, installed, matchKeywords) {
+  const rows = parsedIntent.segments.map((segment) => {
+    const classified = applyFileThresholdSignals(segment.classification, matrix);
+    const { skills, workflow, rulesHint } = collectSkills(segment.text, matrix, classified, matchKeywords);
+    return {
+      index: segment.index,
+      subtask: segment.text,
+      weight: classified.weight,
+      emoji: WEIGHT_EMOJI[classified.weight],
+      reason: classified.reasons.join("; "),
+      skills: skills.map((name) => ({ name, status: skillStatus(name, registry, installed) })),
+      workflow,
+      rulesHint,
+      taskType: classified.taskType || null
+    };
+  });
+
+  let overall = "light";
+  for (const r of rows) if (WEIGHT_RANK[r.weight] > WEIGHT_RANK[overall]) overall = r.weight;
+  if (rows.length >= 2 && WEIGHT_RANK[overall] < WEIGHT_RANK.medium) overall = matrix.classification.multi_item_bundle_min || "medium";
+
+  const showPlan = overall !== "light" || rows.length >= 2 || matchKeywords(parsedIntent.rawText, ["skill plan", "which skill", "plan_first"]);
+  const taskTypeResolved = rows.find((r) => r.taskType)?.taskType || null;
+  const providers = deriveProviders(taskTypeResolved, rows[0]?.skills?.map((s) => s.name) || [], rows[0]?.workflow || null);
+  const winner = pickProvider(providers, matrix?.resolver_order || []);
+
+  return { rows, overall, showPlan, taskTypeResolved, providers, winner, confidence: winner?.confidence_base || 0 };
+}
+
+module.exports = { routeCapability };

package/src/lib/context-memory-bridge.js

@@ -0,0 +1,87 @@
+const fs = require("fs");
+const path = require("path");
+const { resolveProviderActivation } = require("./providers/activation-policy");
+const { createMemoryProviderStub } = require("./providers/memory-provider");
+const { createGraphProviderStub } = require("./providers/graph-provider");
+const { buildLocalContextPack } = require("./context-pack");
+const { search: localMemorySearch } = require("./providers/local-memory-adapter");
+const { query: localGraphQuery } = require("./providers/local-graph-adapter");
+
+function doctorPassQuick(rootDir) {
+  const matrixPath = path.join(rootDir, "skill-routing-matrix.json");
+  const registryPath = path.join(rootDir, "registry.json");
+  if (!fs.existsSync(matrixPath) || !fs.existsSync(registryPath)) return false;
+  try {
+    JSON.parse(fs.readFileSync(matrixPath, "utf-8"));
+    JSON.parse(fs.readFileSync(registryPath, "utf-8"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function localContextEnabled(featureFlags) {
+  if (featureFlags?.local_context === true) return true;
+  return process.env.CAPINT_LOCAL_CONTEXT === "1";
+}
+
+function resolveMemoryStrategy({ intent, routeResult, matrix, rootDir, featureFlags }) {
+  const requiresMemory = routeResult.taskTypeResolved?.requires_memory || "optional";
+  const highRiskCapabilities = new Set(["incident-response", "threat-modeling", "memory-retrieval"]);
+  const hasOverrideSignals = Boolean(intent?.overrides?.workflow || intent?.overrides?.skill);
+
+  let memory = requiresMemory;
+  if (requiresMemory === "none") memory = "none";
+  else if (requiresMemory === "required") memory = "required";
+  else if (highRiskCapabilities.has(routeResult?.taskTypeResolved?.capability) || hasOverrideSignals) {
+    memory = "required";
+  } else memory = "optional";
+
+  const doctorPass = rootDir ? doctorPassQuick(rootDir) : false;
+  const providerActivation = resolveProviderActivation({
+    memoryLevel: memory,
+    overallWeight: routeResult.overall,
+    capability: routeResult?.taskTypeResolved?.capability || null,
+    matrix,
+    doctorPass,
+    featureFlags
+  });
+
+  const providers = {
+    memory: providerActivation.memory.activated ? createMemoryProviderStub("memory-adapter") : createMemoryProviderStub("local"),
+    graph: providerActivation.graph.activated ? createGraphProviderStub("graph-adapter") : createGraphProviderStub("local")
+  };
+
+  const context_pack = buildLocalContextPack({
+    rootDir: rootDir || process.cwd(),
+    memoryLevel: memory,
+    providerActivated: providerActivation.anyActivated
+  });
+
+  let local_adapters = null;
+  if (localContextEnabled(featureFlags) && rootDir) {
+    local_adapters = {
+      memory: localMemorySearch(rootDir, intent?.rawText || ""),
+      graph: localGraphQuery(rootDir, routeResult?.taskTypeResolved?.capability || null)
+    };
+  }
+
+  return {
+    memory,
+    provider_activation: providerActivation,
+    providers_stub: { memory: providers.memory.name, graph: providers.graph.name },
+    context_pack,
+    local_adapters,
+    events: [
+      {
+        type: "route.intent_resolved",
+        capability: routeResult?.taskTypeResolved?.capability || null,
+        memory,
+        providers_activated: providerActivation.anyActivated,
+        local_context: Boolean(local_adapters)
+      }
+    ]
+  };
+}
+
+module.exports = { resolveMemoryStrategy, doctorPassQuick, localContextEnabled };

package/src/lib/context-pack.js

@@ -0,0 +1,39 @@
+const fs = require("fs");
+const path = require("path");
+
+const LOCAL_SOURCES = [
+  { path: "AGENT.md", confidence: "verbatim", role: "session_contract" },
+  { path: "design.md", confidence: "verbatim", role: "project_boundaries" },
+  { path: "HANDOFF.md", confidence: "verbatim", role: "session_history" },
+  { path: ".capint/rules/core.md", confidence: "verbatim", role: "core_rules" }
+];
+
+function buildLocalContextPack({ rootDir, memoryLevel, providerActivated }) {
+  if (memoryLevel === "none") {
+    return { pack_id: null, snippets: [], truncated: false, source: "none" };
+  }
+
+  const snippets = [];
+  for (const src of LOCAL_SOURCES) {
+    const abs = path.join(rootDir, src.path);
+    if (!fs.existsSync(abs)) continue;
+    const text = fs.readFileSync(abs, "utf-8");
+    const excerpt = text.slice(0, providerActivated ? 1200 : 600);
+    snippets.push({
+      text: excerpt,
+      source: src.path,
+      confidence: src.confidence,
+      role: src.role
+    });
+  }
+
+  return {
+    pack_id: `local-${Date.now()}`,
+    snippets,
+    truncated: snippets.some((s) => s.text.length >= 600),
+    source: providerActivated ? "local+provider_hint" : "local",
+    token_budget_hint: providerActivated ? 2000 : 800
+  };
+}
+
+module.exports = { buildLocalContextPack, LOCAL_SOURCES };

package/src/lib/contract.js

@@ -0,0 +1,71 @@
+const EXECUTION_INTENT_KEYS = [
+  "intent",
+  "capability",
+  "resolution",
+  "memory",
+  "plan",
+  "confirm",
+  "confirm_question",
+  "confirm_options",
+  "confirm_default_option",
+  "fallback"
+];
+
+const OPTIONAL_KEYS = [
+  "verification_required",
+  "verification_hints",
+  "route_explain",
+  "provider_activation",
+  "resolution_status",
+  "resolution_hint",
+  "local_adapters"
+];
+
+function validateExecutionIntent(ei) {
+  const errors = [];
+  if (!ei || typeof ei !== "object") {
+    return { valid: false, errors: ["execution_intent must be an object"] };
+  }
+  for (const key of EXECUTION_INTENT_KEYS) {
+    if (!(key in ei)) errors.push(`missing required key: ${key}`);
+  }
+  if (typeof ei.intent !== "string") errors.push("intent must be string");
+  if (typeof ei.capability !== "string") errors.push("capability must be string");
+  if (typeof ei.resolution !== "string") errors.push("resolution must be string");
+  if (!["none", "optional", "required"].includes(ei.memory)) {
+    errors.push("memory must be none|optional|required");
+  }
+  if (!["auto", "confirm", "override"].includes(ei.plan)) {
+    errors.push("plan must be auto|confirm|override");
+  }
+  if (ei.confirm && typeof ei.confirm !== "object") errors.push("confirm must be object");
+  if (Array.isArray(ei.confirm_options)) {
+    for (const o of ei.confirm_options) {
+      if (!o.id || !o.label) errors.push("confirm_options entries need id and label");
+    }
+  }
+  if (typeof ei.verification_required === "boolean" && ei.verification_required) {
+    if (!Array.isArray(ei.verification_hints) || ei.verification_hints.length === 0) {
+      errors.push("verification_required=true requires verification_hints array");
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+function stripVolatile(result) {
+  const copy = JSON.parse(JSON.stringify(result));
+  delete copy.installed_count;
+  delete copy.events;
+  delete copy.event_log;
+  if (copy.execution_intent?.route_explain) {
+    copy.execution_intent.route_explain = { ...copy.execution_intent.route_explain, ts: "<stripped>" };
+  }
+  return copy;
+}
+
+module.exports = {
+  EXECUTION_INTENT_KEYS,
+  OPTIONAL_KEYS,
+  validateExecutionIntent,
+  stripVolatile
+};