kibi-cli 0.1.6 → 0.2.0

package/dist/cli.js

@@ -67,6 +67,7 @@ program
     .command("sync")
     .description("Sync entities from documents")
     .option("--validate-only", "Perform validation without mutations")
+    .option("--rebuild", "Rebuild branch snapshot from scratch (discards current KB)")
     .action(async (options) => {
     await syncCommand(options);
 });
@@ -114,9 +115,10 @@ program
     .command("branch")
     .description("Manage branch KBs")
     .argument("<action>", "Action: ensure")
-    .action(async (action) => {
+    .option("--from <branch>", "Source branch to copy KB from")
+    .action(async (action, options) => {
     if (action === "ensure") {
-        await branchEnsureCommand();
+        await branchEnsureCommand(options);
     }
 });
 program.parse(process.argv);

package/dist/commands/aggregated-checks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregated-checks.d.ts","sourceRoot":"","sources":["../../src/commands/aggregated-checks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAmB,MAAM,cAAc,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,aAAa,EACrB,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,GACjC,OAAO,CAAC,SAAS,EAAE,CAAC,CAoFtB"}
+{"version":3,"file":"aggregated-checks.d.ts","sourceRoot":"","sources":["../../src/commands/aggregated-checks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAmB,MAAM,cAAc,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAU5C;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,aAAa,EACrB,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,GACjC,OAAO,CAAC,SAAS,EAAE,CAAC,CAqDtB"}

package/dist/commands/aggregated-checks.js

@@ -7,27 +7,6 @@ import { resolveKbPlPath } from "../prolog.js";
  */
 export async function runAggregatedChecks(prolog, rulesAllowlist) {
     const violations = [];
-    // Build the check goal based on allowlist
-    const checkGoals = [];
-    const supportedRules = [
-        "must-priority-coverage",
-        "symbol-coverage",
-        "no-dangling-refs",
-        "no-cycles",
-        "required-fields",
-        "deprecated-adr-no-successor",
-        "domain-contradictions",
-    ];
-    for (const rule of supportedRules) {
-        if (!rulesAllowlist || rulesAllowlist.has(rule)) {
-            // Convert kebab-case to snake_case for Prolog
-            const prologRule = rule.replace(/-/g, "_");
-            checkGoals.push(`findall(V, checks:check_${prologRule}(V), ${prologRule}_violations)`);
-        }
-    }
-    if (checkGoals.length === 0) {
-        return violations;
-    }
     const checksPlPath = path.join(path.dirname(resolveKbPlPath()), "checks.pl");
     const checksPlPathEscaped = checksPlPath.replace(/'/g, "''");
     const query = `(use_module('${checksPlPathEscaped}'), call(checks:check_all_json(JsonString)))`;
@@ -37,37 +16,33 @@ export async function runAggregatedChecks(prolog, rulesAllowlist) {
             console.warn("Aggregated checks query failed, falling back to individual checks");
             return [];
         }
-        // Parse the JSON from the binding
         let violationsDict;
         try {
             const jsonString = result.bindings.JsonString;
-            if (jsonString) {
-                violationsDict = JSON.parse(jsonString);
-            }
-            else {
+            if (!jsonString) {
                 throw new Error("No JSON string in binding");
             }
+            let parsed = JSON.parse(jsonString);
+            if (typeof parsed === "string") {
+                parsed = JSON.parse(parsed);
+            }
+            violationsDict = parsed;
         }
         catch (parseError) {
             console.warn("Failed to parse violations JSON:", parseError);
             return [];
         }
-        // Convert Prolog violation terms to Violation objects
-        for (const [ruleKey, ruleViolations] of Object.entries(violationsDict)) {
-            const rule = ruleKey.replace(/_/g, "-");
+        for (const ruleViolations of Object.values(violationsDict)) {
             for (const v of ruleViolations) {
-                if (typeof v === "string") {
-                    // Parse Prolog violation/5 term: violation(Rule, EntityId, Desc, Sugg, Source)
-                    const match = v.match(/violation\(([^,]+),\s*'([^']+)'\s*,\s*"([^"]*)"\s*,\s*"([^"]*)"\s*,\s*"([^"]*)"\)/);
-                    if (match) {
-                        violations.push({
-                            rule: rule,
-                            entityId: match[2],
-                            description: match[3],
-                            suggestion: match[4] || undefined,
-                            source: match[5] || undefined,
-                        });
-                    }
+                const isAllowed = !rulesAllowlist || rulesAllowlist.has(v.rule);
+                if (isAllowed) {
+                    violations.push({
+                        rule: v.rule,
+                        entityId: v.entityId,
+                        description: v.description,
+                        suggestion: v.suggestion || undefined,
+                        source: v.source || undefined,
+                    });
                 }
             }
         }

package/dist/commands/branch.d.ts

@@ -1,3 +1,6 @@
-export declare function branchEnsureCommand(): Promise<void>;
+export interface BranchEnsureOptions {
+    from?: string;
+}
+export declare function branchEnsureCommand(options?: BranchEnsureOptions): Promise<void>;
 export default branchEnsureCommand;
 //# sourceMappingURL=branch.d.ts.map

package/dist/commands/branch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"branch.d.ts","sourceRoot":"","sources":["../../src/commands/branch.ts"],"names":[],"mappings":"AAiDA,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAoBzD;AAED,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"branch.d.ts","sourceRoot":"","sources":["../../src/commands/branch.ts"],"names":[],"mappings":"AAwDA,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AA+DD,wBAAsB,mBAAmB,CACvC,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED,eAAe,mBAAmB,CAAC"}

package/dist/commands/branch.js

@@ -42,25 +42,75 @@
       fi
     done
 */
-import { execSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
-export async function branchEnsureCommand() {
-    const branch = execSync("git branch --show-current", {
-        encoding: "utf-8",
-    }).trim();
+import { copyCleanSnapshot, getBranchDiagnostic, isValidBranchName, resolveActiveBranch, resolveDefaultBranch, } from "../utils/branch-resolver.js";
+import { loadConfig } from "../utils/config.js";
+function resolveExplicitFromBranch(fromBranch) {
+    if (!isValidBranchName(fromBranch)) {
+        console.warn(`Warning: invalid branch name provided via --from: '${fromBranch}'`);
+        return null;
+    }
+    const fromPath = path.join(process.cwd(), ".kb/branches", fromBranch);
+    if (fs.existsSync(fromPath)) {
+        return fromBranch;
+    }
+    console.warn(`Warning: --from branch '${fromBranch}' KB does not exist`);
+    return null;
+}
+function resolveDefaultSourceBranch() {
+    const config = loadConfig(process.cwd());
+    const defaultResult = resolveDefaultBranch(process.cwd(), config);
+    if ("branch" in defaultResult) {
+        const defaultBranch = defaultResult.branch;
+        const defaultPath = path.join(process.cwd(), ".kb/branches", defaultBranch);
+        if (fs.existsSync(defaultPath)) {
+            return defaultBranch;
+        }
+    }
+    else {
+        console.warn(`Warning: could not resolve default branch: ${defaultResult.error}`);
+    }
+    return null;
+}
+function determineSourceBranch(explicitFromBranch) {
+    if (explicitFromBranch) {
+        const fromResult = resolveExplicitFromBranch(explicitFromBranch);
+        if (fromResult) {
+            return fromResult;
+        }
+    }
+    return resolveDefaultSourceBranch();
+}
+function createBranchKbFromSource(sourceBranch, targetBranch) {
+    const sourcePath = path.join(process.cwd(), ".kb/branches", sourceBranch);
+    const targetPath = path.join(process.cwd(), ".kb/branches", targetBranch);
+    copyCleanSnapshot(sourcePath, targetPath);
+    console.log(`Created branch KB: ${targetBranch} (from ${sourceBranch})`);
+}
+function createEmptyBranchKb(branch) {
     const kbPath = path.join(process.cwd(), ".kb/branches", branch);
-    const mainPath = path.join(process.cwd(), ".kb/branches/main");
-    if (!fs.existsSync(mainPath)) {
-        console.warn("Warning: main branch KB does not exist, skipping branch ensure");
+    fs.mkdirSync(kbPath, { recursive: true });
+    console.log(`Created branch KB: ${branch} (empty schema)`);
+}
+export async function branchEnsureCommand(options) {
+    const branchResult = resolveActiveBranch(process.cwd());
+    if ("error" in branchResult) {
+        console.error(getBranchDiagnostic(undefined, branchResult.error));
+        throw new Error(`Failed to resolve active branch: ${branchResult.error}`);
+    }
+    const currentBranch = branchResult.branch;
+    const kbPath = path.join(process.cwd(), ".kb/branches", currentBranch);
+    if (fs.existsSync(kbPath)) {
+        console.log(`Branch KB already exists: ${currentBranch}`);
         return;
     }
-    if (!fs.existsSync(kbPath)) {
-        fs.cpSync(mainPath, kbPath, { recursive: true });
-        console.log(`Created branch KB: ${branch}`);
+    const sourceBranch = determineSourceBranch(options?.from);
+    if (sourceBranch) {
+        createBranchKbFromSource(sourceBranch, currentBranch);
     }
     else {
-        console.log(`Branch KB already exists: ${branch}`);
+        createEmptyBranchKb(currentBranch);
     }
 }
 export default branchEnsureCommand;

package/dist/commands/check.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/commands/check.ts"],"names":[],"mappings":"AAsDA,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAqMvE"}
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/commands/check.ts"],"names":[],"mappings":"AA+DA,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA2OvE"}

package/dist/commands/check.js

@@ -45,11 +45,12 @@
 import * as path from "node:path";
 import { PrologProcess } from "../prolog.js";
 import { getStagedFiles } from "../traceability/git-staged.js";
+import { validateStagedMarkdown } from "../traceability/markdown-validate.js";
 import { extractSymbolsFromStagedFile } from "../traceability/symbol-extract.js";
-import { cleanupTempKb, consultOverlay, createOverlayFacts, createTempKb } from "../traceability/temp-kb.js";
-import { formatViolations as formatStagedViolations, validateStagedSymbols } from "../traceability/validate.js";
-import { getCurrentBranch } from "./init-helpers.js";
+import { cleanupTempKb, consultOverlay, createOverlayFacts, createTempKb, } from "../traceability/temp-kb.js";
+import { formatViolations as formatStagedViolations, validateStagedSymbols, } from "../traceability/validate.js";
 import { runAggregatedChecks } from "./aggregated-checks.js";
+import { getCurrentBranch } from "./init-helpers.js";
 export async function checkCommand(options) {
     try {
         // Resolve KB path with priority:
@@ -86,9 +87,28 @@ export async function checkCommand(options) {
                     console.log("No staged files found.");
                     process.exit(0);
                 }
-                // Extract symbols from staged files
+                const codeFiles = stagedFiles.filter((f) => !f.path.endsWith(".md"));
+                const markdownFiles = stagedFiles.filter((f) => f.path.endsWith(".md"));
+                const markdownErrors = [];
+                for (const f of markdownFiles) {
+                    const result = validateStagedMarkdown(f.path, f.content || "");
+                    for (const err of result.errors) {
+                        markdownErrors.push(err.toString());
+                    }
+                }
+                if (markdownErrors.length > 0) {
+                    console.log("Found embedded entity violations in staged markdown files:");
+                    for (const err of markdownErrors) {
+                        console.log(err);
+                        console.log();
+                    }
+                    if (options.dryRun) {
+                        process.exit(0);
+                    }
+                    process.exit(1);
+                }
                 const allSymbols = [];
-                for (const f of stagedFiles) {
+                for (const f of codeFiles) {
                     try {
                         const symbols = extractSymbolsFromStagedFile(f);
                         if (symbols && symbols.length) {
@@ -99,8 +119,12 @@ export async function checkCommand(options) {
                         console.error(`Error extracting symbols from staged file ${f.path}: ${e instanceof Error ? e.message : String(e)}`);
                     }
                 }
+                if (allSymbols.length === 0 && markdownFiles.length === 0) {
+                    console.log("No exported symbols or markdown entities found in staged files.");
+                    process.exit(0);
+                }
                 if (allSymbols.length === 0) {
-                    console.log("No exported symbols found in staged files.");
+                    console.log("✓ No violations found in staged files.");
                     process.exit(0);
                 }
                 // Create temp KB
@@ -111,7 +135,10 @@ export async function checkCommand(options) {
                 await fs.writeFile(tempCtx.overlayPath, overlayFacts, "utf8");
                 await consultOverlay(tempCtx);
                 // Validate staged symbols using the temp KB prolog session
-                const violationsRaw = await validateStagedSymbols({ minLinks, prolog: tempCtx.prolog });
+                const violationsRaw = await validateStagedSymbols({
+                    minLinks,
+                    prolog: tempCtx.prolog,
+                });
                 const violationsFormatted = formatStagedViolations(violationsRaw);
                 if (violationsRaw && violationsRaw.length > 0) {
                     console.log(violationsFormatted);
@@ -167,16 +194,16 @@ export async function checkCommand(options) {
         // This is significantly faster in Bun/Docker environments where one-shot mode
         // spawns a new Prolog process for each query
         const supportedRules = [
-            'must-priority-coverage',
-            'symbol-coverage',
-            'no-dangling-refs',
-            'no-cycles',
-            'required-fields',
-            'deprecated-adr-no-successor',
-            'domain-contradictions',
+            "must-priority-coverage",
+            "symbol-coverage",
+            "no-dangling-refs",
+            "no-cycles",
+            "required-fields",
+            "deprecated-adr-no-successor",
+            "domain-contradictions",
         ];
         const canUseAggregated = !rulesAllowlist ||
-            Array.from(rulesAllowlist).every(r => supportedRules.includes(r));
+            Array.from(rulesAllowlist).every((r) => supportedRules.includes(r));
         if (canUseAggregated) {
             // Fast path: single Prolog call returning all violations
             const aggregatedViolations = await runAggregatedChecks(prolog, rulesAllowlist);
@@ -193,14 +220,6 @@ export async function checkCommand(options) {
             await runCheck("deprecated-adr-no-successor", checkDeprecatedAdrs);
             await runCheck("domain-contradictions", checkDomainContradictions);
         }
-        await runCheck("must-priority-coverage", checkMustPriorityCoverage);
-        await runCheck("symbol-coverage", checkSymbolCoverage);
-        await runCheck("no-dangling-refs", checkNoDanglingRefs);
-        await runCheck("no-cycles", checkNoCycles);
-        const allEntityIds = await getAllEntityIds(prolog);
-        await runCheck("required-fields", checkRequiredFields, allEntityIds);
-        await runCheck("deprecated-adr-no-successor", checkDeprecatedAdrs);
-        await runCheck("domain-contradictions", checkDomainContradictions);
         await prolog.query("kb_detach");
         await prolog.terminate();
         if (violations.length === 0) {

package/dist/commands/doctor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAsDA,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAsDnD"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAsDA,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CA0DnD"}

package/dist/commands/doctor.js

@@ -71,6 +71,10 @@ export async function doctorCommand() {
             name: "pre-commit hook",
             check: checkPreCommitHook,
         },
+        {
+            name: "post-rewrite hook",
+            check: checkPostRewriteHook,
+        },
     ];
     console.log("Kibi Environment Diagnostics\n");
     let allPassed = true;
@@ -287,3 +291,56 @@ function checkPreCommitHook() {
         };
     }
 }
+function checkPostRewriteHook() {
+    const postCheckoutPath = path.join(process.cwd(), ".git/hooks/post-checkout");
+    const postMergePath = path.join(process.cwd(), ".git/hooks/post-merge");
+    const postRewritePath = path.join(process.cwd(), ".git/hooks/post-rewrite");
+    const postCheckoutExists = existsSync(postCheckoutPath);
+    const postMergeExists = existsSync(postMergePath);
+    if (!postCheckoutExists && !postMergeExists) {
+        return {
+            passed: true,
+            message: "Not installed (optional)",
+        };
+    }
+    const postRewriteExists = existsSync(postRewritePath);
+    if (!postRewriteExists) {
+        return {
+            passed: false,
+            message: "Not installed",
+            remediation: "Run: kibi init --hooks",
+        };
+    }
+    try {
+        const postRewriteStats = statSync(postRewritePath);
+        const postRewriteExecutable = (postRewriteStats.mode & 0o111) !== 0;
+        // Read hook content to verify it invokes kibi
+        const content = readFileSync(postRewritePath, "utf-8");
+        const usesKibi = content.includes("kibi sync");
+        if (!usesKibi) {
+            return {
+                passed: false,
+                message: "post-rewrite hook installed but does not invoke kibi",
+                remediation: "Run: kibi init --hooks to install recommended hooks",
+            };
+        }
+        if (postRewriteExecutable) {
+            return {
+                passed: true,
+                message: "Installed and executable",
+            };
+        }
+        return {
+            passed: false,
+            message: "Installed but not executable",
+            remediation: "Run: chmod +x .git/hooks/post-rewrite",
+        };
+    }
+    catch (error) {
+        return {
+            passed: false,
+            message: "Unable to check hook permissions or read content",
+            remediation: "Run: kibi init --hooks",
+        };
+    }
+}

package/dist/commands/gc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gc.d.ts","sourceRoot":"","sources":["../../src/commands/gc.ts"],"names":[],"mappings":"AAiDA,wBAAsB,SAAS,CAAC,OAAO,EAAE;IACvC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,iBAkFA;AAED,eAAe,SAAS,CAAC"}
+{"version":3,"file":"gc.d.ts","sourceRoot":"","sources":["../../src/commands/gc.ts"],"names":[],"mappings":"AAmDA,wBAAsB,SAAS,CAAC,OAAO,EAAE;IACvC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,iBAsGA;AAED,eAAe,SAAS,CAAC"}

package/dist/commands/gc.js

@@ -45,6 +45,8 @@
 import { execSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { resolveDefaultBranch } from "../utils/branch-resolver.js";
+import { loadConfig } from "../utils/config.js";
 export async function gcCommand(options) {
     // If force is true, perform deletion. Otherwise default to dry run.
     const dryRun = options?.force ? false : (options?.dryRun ?? true);
@@ -85,7 +87,28 @@ export async function gcCommand(options) {
             .readdirSync(kbRoot, { withFileTypes: true })
             .filter((d) => d.isDirectory())
             .map((d) => d.name);
-        const staleBranches = kbBranches.filter((kb) => kb !== "main" && !gitBranches.has(kb));
+        // Resolve configured/default branch to protect
+        const config = loadConfig(process.cwd());
+        // Prefer explicit configured defaultBranch if set
+        const configured = config?.defaultBranch;
+        let defaultBranch;
+        if (configured && typeof configured === "string" && configured.trim()) {
+            defaultBranch = configured.trim();
+        }
+        else {
+            const resolved = resolveDefaultBranch(process.cwd(), config);
+            defaultBranch =
+                "branch" in resolved && typeof resolved.branch === "string"
+                    ? resolved.branch
+                    : "main";
+        }
+        // Protect resolved branch and its 'master'->'main' normalization
+        const protectedBranches = new Set([defaultBranch]);
+        if (defaultBranch === "main")
+            protectedBranches.add("master");
+        if (defaultBranch === "master")
+            protectedBranches.add("main");
+        const staleBranches = kbBranches.filter((kb) => !protectedBranches.has(kb) && !gitBranches.has(kb));
         // Perform deletion when dryRun is false (force requested)
         const performDelete = !dryRun;
         let deletedCount = 0;

package/dist/commands/init-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init-helpers.d.ts","sourceRoot":"","sources":["../../src/commands/init-helpers.ts"],"names":[],"mappings":"AAkFA,wBAAsB,gBAAgB,CACpC,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,MAAM,CAAC,CAejB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,IAAI,CAQN;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAMpD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAajD;AAED,wBAAsB,eAAe,CACnC,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAuBnE;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAapD"}
+{"version":3,"file":"init-helpers.d.ts","sourceRoot":"","sources":["../../src/commands/init-helpers.ts"],"names":[],"mappings":"AA8GA,wBAAsB,gBAAgB,CACpC,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,MAAM,CAAC,CASjB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,IAAI,CAQN;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAMpD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAajD;AAED,wBAAsB,eAAe,CACnC,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAuBnE;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAiBpD"}

package/dist/commands/init-helpers.js

@@ -45,44 +45,60 @@
 import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
 import * as path from "node:path";
 import fg from "fast-glob";
+import { getBranchDiagnostic, resolveActiveBranch, } from "../utils/branch-resolver.js";
+import { DEFAULT_CONFIG } from "../utils/config.js";
 const POST_CHECKOUT_HOOK = `#!/bin/sh
-kibi sync
+# post-checkout hook for kibi
+# Parameters: old_ref new_ref branch_flag
+# branch_flag is 1 for branch checkout, 0 for file checkout
+
+old_ref=$1
+new_ref=$2
+branch_flag=$3
+
+if [ "$branch_flag" = "1" ]; then
+  # Try to resolve the branch we just left (strip decorations like ^ and ~)
+  old_branch=$(git name-rev --name-only "$old_ref" 2>/dev/null | sed 's/\^.*//')
+
+  # Basic validation: non-empty and does not contain ~ or ^
+  if [ -n "$old_branch" ] && echo "$old_branch" | grep -qv '[~^]'; then
+    kibi branch ensure --from "$old_branch" && kibi sync
+  else
+    kibi branch ensure && kibi sync
+  fi
+fi
 `;
 const POST_MERGE_HOOK = `#!/bin/sh
+# post-merge hook for kibi
+# Parameter: squash_flag (not used)
+
 kibi sync
 `;
+const POST_REWRITE_HOOK = `#!/bin/sh
+# post-rewrite hook for kibi
+# Triggered after git rebase, git commit --amend, etc.
+# Parameter: rewrite_type (rebase or amend)
+
+rewrite_type=$1
+
+if [ "$rewrite_type" = "rebase" ]; then
+  kibi sync
+fi
+`;
 const PRE_COMMIT_HOOK = `#!/bin/sh
+# pre-commit hook for kibi
+# Blocks commits if kibi check finds violations
+
 set -e
 kibi check --staged
 `;
-const DEFAULT_CONFIG = {
-    paths: {
-        requirements: "requirements",
-        scenarios: "scenarios",
-        tests: "tests",
-        adr: "adr",
-        flags: "flags",
-        events: "events",
-        facts: "facts",
-        symbols: "symbols.yaml",
-    },
-};
 export async function getCurrentBranch(cwd = process.cwd()) {
-    let currentBranch = "develop";
-    try {
-        const { execSync } = await import("node:child_process");
-        const branch = execSync("git branch --show-current", {
-            cwd,
-            encoding: "utf8",
-        }).trim();
-        if (branch && branch !== "master") {
-            currentBranch = branch;
-        }
-    }
-    catch {
-        currentBranch = "develop";
+    const result = resolveActiveBranch(cwd);
+    if ("error" in result) {
+        console.error(getBranchDiagnostic(undefined, result.error));
+        throw new Error(`Failed to resolve active branch: ${result.error}`);
     }
-    return currentBranch;
+    return result.branch;
 }
 export function createKbDirectoryStructure(kbDir, currentBranch) {
     mkdirSync(kbDir, { recursive: true });
@@ -144,9 +160,11 @@ export function installGitHooks(gitDir) {
     mkdirSync(hooksDir, { recursive: true });
     const postCheckoutPath = path.join(hooksDir, "post-checkout");
     const postMergePath = path.join(hooksDir, "post-merge");
+    const postRewritePath = path.join(hooksDir, "post-rewrite");
     const preCommitPath = path.join(hooksDir, "pre-commit");
     installHook(postCheckoutPath, POST_CHECKOUT_HOOK.replace("#!/bin/sh\n", ""));
     installHook(postMergePath, POST_MERGE_HOOK.replace("#!/bin/sh\n", ""));
+    installHook(postRewritePath, POST_REWRITE_HOOK.replace("#!/bin/sh\n", ""));
     installHook(preCommitPath, PRE_COMMIT_HOOK.replace("#!/bin/sh\n", ""));
-    console.log("✓ Installed git hooks (pre-commit, post-checkout, post-merge)");
+    console.log("✓ Installed git hooks (pre-commit, post-checkout, post-merge, post-rewrite)");
 }

package/dist/commands/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AA4DA,UAAU,WAAW;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAsCrE"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AA4DA,UAAU,WAAW;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA6DrE"}

package/dist/commands/init.js

@@ -45,13 +45,34 @@
 import { existsSync } from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { copySchemaFiles, createConfigFile, createKbDirectoryStructure, getCurrentBranch, installGitHooks, updateGitIgnore, } from "./init-helpers.js";
+import { resolveActiveBranch } from "../utils/branch-resolver.js";
+import { copySchemaFiles, createConfigFile, createKbDirectoryStructure, installGitHooks, updateGitIgnore, } from "./init-helpers.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export async function initCommand(options) {
     const kbDir = path.join(process.cwd(), ".kb");
     const kbExists = existsSync(kbDir);
-    const currentBranch = await getCurrentBranch();
+    // Resolve branch: allow non-git repos to use default "main" for init
+    let currentBranch;
+    const result = resolveActiveBranch();
+    if ("error" in result) {
+        const isNonGitError = result.code === "NOT_A_GIT_REPO" || result.code === "GIT_NOT_AVAILABLE";
+        if (isNonGitError) {
+            // For init command, use "main" as default branch when not in a git repo.
+            // This allows initialization before git init, which is useful for first-time setup.
+            console.warn("Warning: Not in a git repository");
+            console.warn("Using 'main' as default branch. Run 'kibi sync' in a git repo for proper branch-aware behavior.");
+            currentBranch = "main";
+        }
+        else {
+            console.error("Error: Failed to resolve the active git branch.");
+            console.error(result.error);
+            process.exit(1);
+        }
+    }
+    else {
+        currentBranch = result.branch;
+    }
     try {
         if (!kbExists) {
             createKbDirectoryStructure(kbDir, currentBranch);

package/dist/commands/query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/commands/query.ts"],"names":[],"mappings":"AAoDA,UAAU,YAAY;IACpB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,IAAI,CAAC,CAwKf"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/commands/query.ts"],"names":[],"mappings":"AAqDA,UAAU,YAAY;IACpB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,IAAI,CAAC,CAmLf"}

package/dist/commands/query.js

@@ -46,24 +46,33 @@ import * as path from "node:path";
 import Table from "cli-table3";
 import { PrologProcess } from "../prolog.js";
 import relationshipSchema from "../public/schemas/relationship.js";
+import { resolveActiveBranch } from "../utils/branch-resolver.js";
 const REL_TYPES = relationshipSchema.properties.type.enum;
 export async function queryCommand(type, options) {
     try {
         const prolog = new PrologProcess({ timeout: 120000 });
         await prolog.start();
         await prolog.query("set_prolog_flag(answer_write_options, [max_depth(0), spacing(next_argument)])");
-        let currentBranch = "main";
-        try {
-            const { execSync } = await import("node:child_process");
-            currentBranch = execSync("git branch --show-current", {
-                cwd: process.cwd(),
-                encoding: "utf8",
-            }).trim();
-            if (!currentBranch || currentBranch === "master")
+        // Resolve branch: allow non-git repos to use default "main" for query
+        let currentBranch;
+        const branchResult = resolveActiveBranch();
+        if ("error" in branchResult) {
+            const isNonGitError = branchResult.code === "NOT_A_GIT_REPO" ||
+                branchResult.code === "GIT_NOT_AVAILABLE";
+            if (isNonGitError) {
+                // For query command, use "main" as default branch when git is not available
+                // or the current directory is not a git repository. This allows querying
+                // after init in a non-git directory.
                 currentBranch = "main";
+            }
+            else {
+                console.error(`Error: Failed to resolve active branch:\n${branchResult.error}`);
+                await prolog.terminate();
+                process.exit(1);
+            }
         }
-        catch {
-            currentBranch = "main";
+        else {
+            currentBranch = branchResult.branch;
         }
         const kbPath = path.join(process.cwd(), `.kb/branches/${currentBranch}`);
         const attachResult = await prolog.query(`kb_attach('${kbPath}')`);