@bcelep/capint 0.4.2

package/src/lib/scaffold/index.js

@@ -0,0 +1,29 @@
+const { applyFilePolicy, buildReport } = require("./file-policy");
+const { getPresetFiles, PRESET_MANIFEST, copyBundle } = require("./presets");
+const { writeScaffoldManifest } = require("./manifest");
+
+function runScaffold({ rootDir, preset = "minimal", projectName = "project", force = false }) {
+  if (!PRESET_MANIFEST[preset]) {
+    return { error: `unknown preset: ${preset}. Available: ${Object.keys(PRESET_MANIFEST).join(", ")}` };
+  }
+
+  const files = getPresetFiles(preset, {
+    project_name: projectName,
+    date: new Date().toISOString().slice(0, 10)
+  });
+
+  const results = [];
+  for (const [rel, content] of Object.entries(files)) {
+    results.push(applyFilePolicy({ rootDir, relativePath: rel, content, force }));
+  }
+
+  results.push(...copyBundle({ rootDir, force }));
+
+  const report = buildReport(results);
+  report.preset = preset;
+  report.manifest = PRESET_MANIFEST[preset];
+  report.manifest_path = writeScaffoldManifest(rootDir, report);
+  return report;
+}
+
+module.exports = { runScaffold, PRESET_MANIFEST };

package/src/lib/scaffold/manifest-schema.js

@@ -0,0 +1,116 @@
+const MANIFEST_SCHEMA_VERSION = "2.0";
+
+const ACTIONS = new Set(["created", "updated", "skipped", "conflict"]);
+const SOURCES = new Set(["capint", "user"]);
+const KINDS = new Set(["doc", "skill", "workflow", "matrix", "registry", "ide_projection"]);
+
+function inferKindFromPath(relPath) {
+  const p = relPath.replace(/\\/g, "/");
+  if (p.startsWith("skills/")) return "skill";
+  if (p.startsWith("workflows/")) return "workflow";
+  if (p === "skill-routing-matrix.json") return "matrix";
+  if (p === "registry.json") return "registry";
+  if (
+    p.includes(".cursor/rules/") ||
+    p === "CLAUDE.md" ||
+    p === "GEMINI.md" ||
+    p.startsWith(".agents/")
+  ) {
+    return "ide_projection";
+  }
+  return "doc";
+}
+
+function defaultFileMeta(relPath, overrides = {}) {
+  const kind = overrides.kind || inferKindFromPath(relPath);
+  const source = overrides.source || "capint";
+  const removable =
+    typeof overrides.removable === "boolean"
+      ? overrides.removable
+      : source === "capint" && kind !== "doc";
+  return {
+    path: relPath.replace(/\\/g, "/"),
+    source,
+    removable,
+    kind,
+    marker: overrides.marker ?? null
+  };
+}
+
+function enrichFileEntry(entry) {
+  const pathNorm = (entry.path || "").replace(/\\/g, "/");
+  const meta = defaultFileMeta(pathNorm, {
+    source: entry.source,
+    removable: entry.removable,
+    kind: entry.kind,
+    marker: entry.marker
+  });
+  return {
+    path: pathNorm,
+    action: entry.action,
+    source: meta.source,
+    removable: meta.removable,
+    kind: meta.kind,
+    marker: meta.marker,
+    sidecar: entry.sidecar || null
+  };
+}
+
+function validateManifest(manifest) {
+  const errors = [];
+  if (!manifest || typeof manifest !== "object") {
+    return { valid: false, errors: ["manifest must be an object"] };
+  }
+  if (manifest.schema_version !== MANIFEST_SCHEMA_VERSION) {
+    errors.push(`schema_version must be ${MANIFEST_SCHEMA_VERSION}`);
+  }
+  if (!Array.isArray(manifest.files)) {
+    errors.push("files must be an array");
+    return { valid: false, errors };
+  }
+  for (let i = 0; i < manifest.files.length; i++) {
+    const f = manifest.files[i];
+    if (!f.path || typeof f.path !== "string") errors.push(`files[${i}].path required`);
+    if (!ACTIONS.has(f.action)) errors.push(`files[${i}].action invalid: ${f.action}`);
+    if (!SOURCES.has(f.source)) errors.push(`files[${i}].source invalid: ${f.source}`);
+    if (typeof f.removable !== "boolean") errors.push(`files[${i}].removable must be boolean`);
+    if (!KINDS.has(f.kind)) errors.push(`files[${i}].kind invalid: ${f.kind}`);
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+function buildManifestDocument({ report, previous = null }) {
+  const files = (report.results || []).map(enrichFileEntry);
+  const manifest = {
+    schema_version: MANIFEST_SCHEMA_VERSION,
+    last_run: report.generated_at,
+    preset: report.preset,
+    summary: report.summary,
+    files,
+    history: [
+      ...(previous?.history || []).slice(-9),
+      {
+        at: report.generated_at,
+        preset: report.preset,
+        summary: report.summary
+      }
+    ]
+  };
+  const validation = validateManifest(manifest);
+  if (!validation.valid) {
+    throw new Error(`manifest validation failed: ${validation.errors.join("; ")}`);
+  }
+  return manifest;
+}
+
+module.exports = {
+  MANIFEST_SCHEMA_VERSION,
+  ACTIONS,
+  SOURCES,
+  KINDS,
+  inferKindFromPath,
+  defaultFileMeta,
+  enrichFileEntry,
+  validateManifest,
+  buildManifestDocument
+};

package/src/lib/scaffold/manifest.js

@@ -0,0 +1,34 @@
+const fs = require("fs");
+const path = require("path");
+const { buildManifestDocument } = require("./manifest-schema");
+
+function writeScaffoldManifest(rootDir, report) {
+  const capintDir = path.join(rootDir, ".capint");
+  if (!fs.existsSync(capintDir)) fs.mkdirSync(capintDir, { recursive: true });
+
+  const manifestPath = path.join(capintDir, "scaffold-manifest.json");
+  let previous = null;
+  if (fs.existsSync(manifestPath)) {
+    try {
+      previous = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+    } catch {
+      previous = null;
+    }
+  }
+
+  const manifest = buildManifestDocument({ report, previous });
+  fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf-8");
+  return manifestPath;
+}
+
+function readScaffoldManifest(rootDir) {
+  const manifestPath = path.join(rootDir, ".capint", "scaffold-manifest.json");
+  if (!fs.existsSync(manifestPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { writeScaffoldManifest, readScaffoldManifest };

package/src/lib/scaffold/presets.js

@@ -0,0 +1,132 @@
+const fs = require("fs");
+const path = require("path");
+const { applyFilePolicy } = require("./file-policy");
+
+function loadTemplate(name) {
+  const tplDir = path.join(__dirname, "..", "..", "..", "templates", name);
+  const files = {};
+  if (!fs.existsSync(tplDir)) return files;
+  for (const rel of walk(tplDir)) {
+    const key = rel.replace(/\\/g, "/");
+    files[key] = fs.readFileSync(path.join(tplDir, rel), "utf-8");
+  }
+  return files;
+}
+
+function walk(dir, base = "") {
+  const out = [];
+  for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+    const rel = base ? `${base}/${ent.name}` : ent.name;
+    if (ent.isDirectory()) out.push(...walk(path.join(dir, ent.name), rel));
+    else out.push(rel);
+  }
+  return out;
+}
+
+function interpolate(content, vars) {
+  let out = content;
+  for (const [k, v] of Object.entries(vars)) {
+    out = out.replace(new RegExp(`\\{\\{${k}\\}\\}`, "g"), v);
+  }
+  return out;
+}
+
+function deriveRegistryFromMatrix(matrix) {
+  const core = new Set(["capability-router"]);
+  const recommended = new Set();
+
+  for (const tt of matrix?.task_types || []) {
+    for (const s of tt.skills || []) {
+      if (s === "capability-router") core.add(s);
+      else recommended.add(s);
+    }
+  }
+  for (const meta of Object.values(matrix?.rules_domain_map || {})) {
+    for (const s of meta.skills || []) {
+      if (s === "capability-router") core.add(s);
+      else recommended.add(s);
+    }
+  }
+  recommended.delete("capability-router");
+
+  return {
+    schema_version: "1.0",
+    core: [...core].sort(),
+    recommended: [...recommended].sort(),
+    optional: [],
+    project_added: []
+  };
+}
+
+function getPresetFiles(preset, vars = {}) {
+  const pkgRoot = path.join(__dirname, "..", "..", "..");
+  const matrixRaw = fs.readFileSync(path.join(pkgRoot, "skill-routing-matrix.json"), "utf-8");
+  const matrix = JSON.parse(matrixRaw);
+  const registryJson = `${JSON.stringify(deriveRegistryFromMatrix(matrix), null, 2)}\n`;
+  const routingBundle = {
+    "skill-routing-matrix.json": matrixRaw,
+    "registry.json": registryJson
+  };
+
+  const presets = {
+    minimal: () => ({ ...loadTemplate("minimal"), ...routingBundle }),
+    "prismx-compatible": () => {
+      const minimal = loadTemplate("minimal");
+      const extra = loadTemplate("prismx-compatible");
+      return { ...minimal, ...extra, ...routingBundle };
+    }
+  };
+  const loader = presets[preset] || presets.minimal;
+  const raw = loader();
+  const files = {};
+  for (const [rel, content] of Object.entries(raw)) {
+    files[rel] = interpolate(content, vars);
+  }
+  return files;
+}
+
+function copyBundle({ rootDir, force = false }) {
+  const bundleDir = path.join(__dirname, "..", "..", "..", "templates", "bundle");
+  const results = [];
+  if (!fs.existsSync(bundleDir)) return results;
+
+  for (const rel of walk(bundleDir)) {
+    const relNorm = rel.replace(/\\/g, "/");
+    const content = fs.readFileSync(path.join(bundleDir, rel), "utf-8");
+    results.push(
+      applyFilePolicy({
+        rootDir,
+        relativePath: relNorm,
+        content,
+        force
+      })
+    );
+  }
+  return results;
+}
+
+const PRESET_MANIFEST = {
+  minimal: {
+    id: "minimal",
+    description: "AGENT.md, design.md, rules, matrix, registry, skill bundle",
+    files: [
+      "AGENT.md",
+      "AGENTS.md",
+      "design.md",
+      ".capint/rules/core.md",
+      ".gitignore",
+      "skill-routing-matrix.json",
+      "registry.json",
+      "skills/",
+      "workflows/"
+    ]
+  },
+  "prismx-compatible": {
+    id: "prismx-compatible",
+    description: "minimal + HANDOFF.md + .capint/context.json",
+    extends: "minimal",
+    files: ["HANDOFF.md", ".capint/context.json"]
+  }
+};
+
+module.exports = { getPresetFiles, PRESET_MANIFEST, interpolate, deriveRegistryFromMatrix, copyBundle };

package/src/lib/uninstall.js

@@ -0,0 +1,126 @@
+const fs = require("fs");
+const path = require("path");
+const { CAPINT_SYNC_MARKER } = require("./ide-sync");
+const { readScaffoldManifest } = require("./scaffold/manifest");
+
+function isCapintMarked(filePath) {
+  if (!fs.existsSync(filePath)) return false;
+  try {
+    return fs.readFileSync(filePath, "utf-8").includes(CAPINT_SYNC_MARKER);
+  } catch {
+    return false;
+  }
+}
+
+function collectManifestRemovals(rootDir, manifest, options = {}) {
+  const plan = [];
+  const { keepAgent = false, keepIde = false, includeSidecars = false } = options;
+
+  for (const entry of manifest?.files || []) {
+    if (entry.source !== "capint" || !entry.removable) continue;
+    if (entry.kind === "ide_projection" && keepIde) continue;
+    if (entry.path === "AGENT.md" && keepAgent) continue;
+    if (entry.path === "design.md" && keepAgent) continue;
+    if (entry.path === "AGENTS.md" && keepAgent) continue;
+
+    const abs = path.join(rootDir, entry.path);
+    if (entry.kind === "ide_projection" && !isCapintMarked(abs)) continue;
+    if (fs.existsSync(abs)) {
+      plan.push({ path: entry.path, abs, type: "file", kind: entry.kind });
+    }
+  }
+
+  if (includeSidecars) {
+    for (const entry of manifest?.files || []) {
+      if (entry.sidecar) {
+        const abs = path.join(rootDir, entry.sidecar);
+        if (fs.existsSync(abs)) plan.push({ path: entry.sidecar, abs, type: "sidecar" });
+      }
+    }
+    for (const ent of fs.readdirSync(rootDir)) {
+      if (ent.endsWith(".capint.new.md")) {
+        plan.push({ path: ent, abs: path.join(rootDir, ent), type: "sidecar" });
+      }
+    }
+  }
+
+  const capintDir = path.join(rootDir, ".capint");
+  if (fs.existsSync(capintDir)) {
+    plan.push({ path: ".capint/", abs: capintDir, type: "dir" });
+  }
+
+  const seen = new Set();
+  return plan.filter((p) => {
+    if (seen.has(p.abs)) return false;
+    seen.add(p.abs);
+    return true;
+  });
+}
+
+function collectIdeFallbackRemovals(rootDir, keepIde) {
+  if (keepIde) return [];
+  const candidates = [
+    path.join(rootDir, ".cursor", "rules", "00-capint-session.mdc"),
+    path.join(rootDir, "CLAUDE.md"),
+    path.join(rootDir, "GEMINI.md"),
+    path.join(rootDir, ".agents", "rules", "00-capint-session.md"),
+    path.join(rootDir, ".agents", "CAPINT.md"),
+    path.join(rootDir, ".agents", "skills", "capint-router", "SKILL.md")
+  ];
+  return candidates
+    .filter((abs) => isCapintMarked(abs))
+    .map((abs) => ({
+      path: path.relative(rootDir, abs).replace(/\\/g, "/"),
+      abs,
+      type: "file",
+      kind: "ide_projection"
+    }));
+}
+
+function buildUninstallPlan(rootDir, options = {}) {
+  const manifest = readScaffoldManifest(rootDir);
+  const fromManifest = manifest
+    ? collectManifestRemovals(rootDir, manifest, options)
+    : [];
+  const fromIde = collectIdeFallbackRemovals(rootDir, options.keepIde);
+  const merged = [...fromManifest, ...fromIde];
+  const seen = new Set();
+  return merged.filter((p) => {
+    if (seen.has(p.abs)) return false;
+    seen.add(p.abs);
+    return true;
+  });
+}
+
+function removePath(entry) {
+  if (entry.type === "dir") {
+    fs.rmSync(entry.abs, { recursive: true, force: true });
+    return;
+  }
+  fs.rmSync(entry.abs, { force: true });
+}
+
+function executeUninstall(rootDir, plan, dryRun) {
+  const removed = [];
+  const skipped = [];
+  for (const entry of plan) {
+    if (!fs.existsSync(entry.abs)) {
+      skipped.push(entry.path);
+      continue;
+    }
+    if (entry.kind === "ide_projection" && !isCapintMarked(entry.abs)) {
+      skipped.push(entry.path);
+      continue;
+    }
+    if (!dryRun) removePath(entry);
+    removed.push(entry.path);
+  }
+  return { removed, skipped };
+}
+
+module.exports = {
+  buildUninstallPlan,
+  executeUninstall,
+  isCapintMarked,
+  collectManifestRemovals
+};

package/src/lib/upgrade-matrix.js

@@ -0,0 +1,120 @@
+const fs = require("fs");
+const path = require("path");
+
+function loadJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+
+function taskTypeIds(matrix) {
+  return new Set((matrix?.task_types || []).map((t) => t.id));
+}
+
+function mergeTaskTypes(packageMatrix, projectMatrix) {
+  const conflicts = [];
+  const customPreserved = [];
+  const pkgById = new Map((packageMatrix.task_types || []).map((t) => [t.id, t]));
+  const projById = new Map((projectMatrix.task_types || []).map((t) => [t.id, t]));
+
+  for (const [id, proj] of projById) {
+    if (!pkgById.has(id)) {
+      customPreserved.push(id);
+    }
+  }
+
+  const merged = [];
+  for (const pkgTt of packageMatrix.task_types || []) {
+    const projTt = projById.get(pkgTt.id);
+    if (!projTt) {
+      merged.push(structuredClone(pkgTt));
+      continue;
+    }
+    const out = structuredClone(pkgTt);
+    for (const key of Object.keys(projTt)) {
+      if (key === "id") continue;
+      const pv = projTt[key];
+      const pkgv = pkgTt[key];
+      if (JSON.stringify(pv) !== JSON.stringify(pkgv)) {
+        conflicts.push({
+          id: pkgTt.id,
+          field: key,
+          project_value: pv,
+          package_value: pkgv,
+          resolution: "package_wins"
+        });
+      }
+    }
+    merged.push(out);
+  }
+
+  for (const id of customPreserved) {
+    merged.push(structuredClone(projById.get(id)));
+  }
+
+  return { merged, conflicts, custom_preserved: customPreserved };
+}
+
+function mergeMatrices(packageMatrix, projectMatrix) {
+  const topKeys = new Set([...Object.keys(packageMatrix), ...Object.keys(projectMatrix)]);
+  const conflicts = [];
+  const result = structuredClone(packageMatrix);
+
+  for (const key of topKeys) {
+    if (key === "task_types") continue;
+    if (!(key in projectMatrix)) continue;
+    if (JSON.stringify(projectMatrix[key]) !== JSON.stringify(packageMatrix[key])) {
+      conflicts.push({
+        id: "_top_level",
+        field: key,
+        project_value: projectMatrix[key],
+        package_value: packageMatrix[key],
+        resolution: "package_wins"
+      });
+    }
+  }
+
+  const tt = mergeTaskTypes(packageMatrix, projectMatrix);
+  result.task_types = tt.merged;
+  return {
+    merged: result,
+    conflicts: [...conflicts, ...tt.conflicts],
+    custom_preserved: tt.custom_preserved
+  };
+}
+
+function planUpgrade(rootDir, packageRoot) {
+  const projectPath = path.join(rootDir, "skill-routing-matrix.json");
+  const packagePath = path.join(packageRoot, "skill-routing-matrix.json");
+
+  if (!fs.existsSync(projectPath)) {
+    return { error: "skill-routing-matrix.json not found in project" };
+  }
+  if (!fs.existsSync(packagePath)) {
+    return { error: "package skill-routing-matrix.json not found" };
+  }
+
+  const projectMatrix = loadJson(projectPath);
+  const packageMatrix = loadJson(packagePath);
+  const { merged, conflicts, custom_preserved } = mergeMatrices(packageMatrix, projectMatrix);
+
+  return {
+    project_schema: projectMatrix.schema_version,
+    package_schema: packageMatrix.schema_version,
+    conflicts,
+    custom_preserved,
+    merged,
+    summary: `${conflicts.length} conflicts — package wins; review before --apply`
+  };
+}
+
+function applyUpgrade(rootDir, merged) {
+  const projectPath = path.join(rootDir, "skill-routing-matrix.json");
+  const backupDir = path.join(rootDir, ".capint", "backups");
+  fs.mkdirSync(backupDir, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupPath = path.join(backupDir, `skill-routing-matrix.${stamp}.json`);
+  fs.copyFileSync(projectPath, backupPath);
+  fs.writeFileSync(projectPath, `${JSON.stringify(merged, null, 2)}\n`, "utf-8");
+  return backupPath;
+}
+
+module.exports = { planUpgrade, applyUpgrade, mergeMatrices };

package/templates/bundle/skills/capability-router/SKILL.md

@@ -0,0 +1,12 @@
+# capability-router
+
+Routes normalized intent to capabilities/providers using `skill-routing-matrix.json`.
+
+## When
+
+- Ambiguous requests with no clear task type
+- Fallback when no keyword match
+
+## CapInt
+
+Default fallback skill · CLI: `capint route "<task>"`

package/templates/bundle/skills/context-memory-bridge/SKILL.md

@@ -0,0 +1,17 @@
+# context-memory-bridge
+
+Use when the task requires prior decisions, handoff context, or session history lookup.
+
+## When
+
+- memory lookup, what did we decide, geçen karar, history
+
+## Steps
+
+1. Read HANDOFF.md, AGENT.md, design.md when present
+2. Summarize relevant prior decisions
+3. Do not invent history; cite file paths
+
+## CapInt
+
+Matrix capability: `memory-retrieval` · Memory: required

package/templates/bundle/skills/localization-hub/SKILL.md

@@ -0,0 +1,17 @@
+# localization-hub
+
+Use for i18n, translation files, locale keys, and language hub tasks.
+
+## When
+
+- User mentions i18n, localization, çeviri, lang file, translation hub
+
+## Steps
+
+1. Identify target locales and key namespaces
+2. Check existing translation patterns in the repo
+3. Apply consistent key naming; avoid hardcoded strings
+
+## CapInt
+
+Matrix capability: `localization-hub`

package/templates/bundle/skills/refactor/SKILL.md

@@ -0,0 +1,17 @@
+# refactor
+
+Use when simplifying code, reducing smell, or cleaning structure without changing behavior.
+
+## When
+
+- refactor, clean up, simplify, code smell
+
+## Steps
+
+1. Ensure tests exist or add minimal coverage
+2. Make smallest structural change
+3. Re-run tests; no behavior change unless intended
+
+## CapInt
+
+Matrix capability: `refactor-simplify` · Workflow: `/forge`

package/templates/bundle/skills/systematic-debugging/SKILL.md

@@ -0,0 +1,19 @@
+# systematic-debugging
+
+Use when fixing bugs, errors, or unexpected behavior before proposing fixes.
+
+## When
+
+- User reports broken behavior, test failures, or regressions
+- Keywords: bug, error, fix, hata, çalışmıyor
+
+## Steps
+
+1. Reproduce the issue with minimal steps
+2. Gather evidence (logs, stack traces)
+3. Form hypothesis; test one change at a time
+4. Verify fix with targeted test
+
+## CapInt
+
+Matrix capability: `systematic-debugging` · Workflow: `/forge`

package/templates/bundle/workflows/forge.md

@@ -0,0 +1,51 @@
+# /forge
+
+Default implementation workflow for medium/heavy tasks after confirm.
+
+Inspired by harness-style phased orchestration; CapInt router selects this workflow for debug/refactor capabilities.
+
+## Execution modes (from confirm option)
+
+| Confirm option | Mode | Behavior |
+|----------------|------|----------|
+| `apply_now` | subagent | Single focused pass, minimal ceremony |
+| `plan_first` | pipeline | Phased plan before edits |
+| `analyze_only` | explore | Read-only analysis, no file writes |
+
+## Phase 0 — Context
+
+1. Read `AGENT.md`, `design.md`, optional `HANDOFF.md`
+2. Use `context_pack` from Execution Intent when memory is optional/required
+3. If ambiguous, stop and ask one clarifying question
+
+## Phase 1 — Intent lock
+
+1. Restate capability + resolution from Execution Intent
+2. List assumptions and success criteria
+3. Wait for confirm unless `apply_now` on light tasks
+
+## Phase 2 — Execute
+
+1. Apply smallest correct change set
+2. Match project conventions; no drive-by refactors
+3. For `producer_reviewer` pattern: implement then self-review before claiming done
+
+## Phase 3 — Verify
+
+1. Run verification hints from Execution Intent
+2. Evidence before claims — no "done" without command output
+3. If verification fails, return to Phase 2 (max 2 retries)
+
+## Phase 4 — Handoff
+
+1. Summarize what changed and why
+2. Note follow-on capabilities from `orchestration.chains` if any
+3. Update `HANDOFF.md` when session material decisions were made
+
+## Error handling
+
+| Situation | Action |
+|-----------|--------|
+| Blocked on missing info | `NEEDS_CONTEXT` — ask user, do not guess |
+| Verification failed | Fix and re-verify; do not skip |
+| Scope creep detected | Split task; route again via `capint consult` |