karajan-code 4.35.1 → 4.36.0

package/src/review/verdict-store.js

@@ -13,6 +13,7 @@ import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { runCommand } from "../utils/process.js";
+import { kjStamp, stampDiffers, stampLabel } from "./kj-provenance.js";
 
 const STORE_DIR = path.join(".karajan", "reviews");
 
@@ -35,6 +36,7 @@ export async function saveVerdict(projectDir, diff, verdict) {
   const hash = diffHash(diff);
   const record = {
     ...verdict,
+    kj: kjStamp(), // KJC-TSK-0886: que kj lo emitio; nunca lo dicta quien llama
     diffHash: hash,
     timestamp: new Date().toISOString(),
   };
@@ -143,5 +145,8 @@ export async function checkVerdict(projectDir, diff) {
   if (verdict.verdict !== "approved") {
     return { ok: false, verdict, reason: `review was rejected by ${verdict.reviewer} — fix the issues and run \`kj review\` again` };
   }
-  return { ok: true, verdict };
+  // KJC-TSK-0886: otro kj comprobando no bloquea, pero deja rastro.
+  const now = kjStamp();
+  if (!stampDiffers(verdict.kj, now)) return { ok: true, verdict };
+  return { ok: true, verdict, note: `verdict from ${stampLabel(verdict.kj)}, checked by ${stampLabel(now)}` };
 }

package/src/start/sweep.js

@@ -17,9 +17,10 @@ import { compareHarden } from "../harden/advisory.js";
 import { detectTestFramework } from "../utils/project-detect.js";
 import { detectQmd } from "../utils/qmd-detect.js";
 import {
-  dbPath, openVecStore, projectSlug, countChunks, getLastIndexedCommit,
+  projectSlug, countChunks, getLastIndexedCommit,
 } from "../rag/vec-store.js";
 import { classifyMaturity } from "./maturity.js";
+import { openProjectStore, projectDbPath } from "../rag/project-store.js";
 
 const CODE_EXT = new Set([
   ".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx", ".py", ".go",
@@ -96,8 +97,8 @@ function lastCommitAgeDays(projectDir) {
 /** Read-only RAG index status; null when no index file exists yet. */
 function readRagStatus(projectDir) {
   try {
-    if (!existsSync(dbPath())) return { indexed: false, chunks: 0, lastIndexedCommit: null };
-    const db = openVecStore();
+    if (!existsSync(projectDbPath(projectDir))) return { indexed: false, chunks: 0, lastIndexedCommit: null };
+    const db = openProjectStore({ projectDir });
     return {
       indexed: true,
       chunks: countChunks(db, { kind: "code" }),

package/src/utils/rulesync.js

@@ -0,0 +1,61 @@
+/**
+ * KJC-TSK-0879 (issue #1310) — Rulesync compatibility.
+ *
+ * A Rulesync-managed repo keeps its agent rules in `.rulesync/rules/` and
+ * `rulesync generate` compiles them into CLAUDE.md, AGENTS.md, .cursor/rules and
+ * the rest, overwriting those files. A block kj writes straight into CLAUDE.md
+ * is erased by the next generate, so in such a repo kj writes into Rulesync's
+ * source instead, with the same managed markers.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+export const RULESYNC_RULE = join(".rulesync", "rules", "karajan.md");
+
+// Rulesync's own rule frontmatter: not the root overview, applies to every
+// target and every file.
+const FRONTMATTER = [
+  "---",
+  "root: false",
+  'targets: ["*"]',
+  'description: "Karajan Code: method, guidelines and playbook (managed by kj)"',
+  'globs: ["**/*"]',
+  "---",
+  "",
+].join("\n");
+
+/** The project uses Rulesync when it has `.rulesync/` or `rulesync.jsonc`. */
+export function detectRulesync(projectDir) {
+  return existsSync(join(projectDir, ".rulesync")) || existsSync(join(projectDir, "rulesync.jsonc"));
+}
+
+/** What a brand-new karajan.md starts with, before kj's managed blocks. */
+export const rulesyncRuleSeed = () => FRONTMATTER;
+
+const GENERATE_ARGS = ["generate", "--targets", "*", "--features", "*"];
+const defaultRun = (cmd, args, cwd) => execFileSync(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" });
+
+/**
+ * Compile kj's rules out to every agent, only when the project declared
+ * `rulesync.generate: true`: kj does not run someone else's compiler on its
+ * own. And never a package fetched on the fly: the local binary, or
+ * `npx --no-install`. A failure is said out loud and does not break the install.
+ */
+export function maybeRulesyncGenerate({ projectDir, config, logger = console, run = defaultRun }) {
+  if (!detectRulesync(projectDir)) return { ran: false, reason: "no-rulesync" };
+  if (config?.rulesync?.generate !== true) {
+    logger.info?.(`kj: its rules are in ${RULESYNC_RULE}; run rulesync generate to reach your agents, or declare rulesync.generate: true`);
+    return { ran: false, reason: "not-opted-in" };
+  }
+  const local = join(projectDir, "node_modules", ".bin", "rulesync");
+  const [cmd, args] = existsSync(local) ? [local, GENERATE_ARGS] : ["npx", ["--no-install", "rulesync", ...GENERATE_ARGS]];
+  try {
+    run(cmd, args, projectDir);
+    logger.info?.("kj: rulesync generate spread kj's rules to every agent");
+    return { ran: true };
+  } catch (err) {
+    logger.warn?.(`kj: rulesync generate failed (${err.message}); kj's rules are in ${RULESYNC_RULE}, run it yourself`);
+    return { ran: false, reason: "failed" };
+  }
+}