kibi-cli 0.1.0

package/dist/commands/doctor.js

@@ -0,0 +1,268 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+/*
+ How to apply this header to source files (examples)
+
+ 1) Prepend header to a single file (POSIX shells):
+
+    cat LICENSE_HEADER.txt "$FILE" > "$FILE".with-header && mv "$FILE".with-header "$FILE"
+
+ 2) Apply to multiple files (example: the project's main entry files):
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp packages/cli/src/*.ts packages/mcp/src/*.ts; do
+      if [ -f "$f" ]; then
+        cp "$f" "$f".bak
+        (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+      fi
+    done
+
+ 3) Avoid duplicating the header: run a quick guard to only add if missing
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp; do
+      if [ -f "$f" ]; then
+        if ! head -n 5 "$f" | grep -q "Copyright (C) 2026 Piotr Franczyk"; then
+          cp "$f" "$f".bak
+          (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+        fi
+      fi
+    done
+*/
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import * as path from "node:path";
+export async function doctorCommand() {
+    const checks = [
+        {
+            name: "SWI-Prolog",
+            check: checkSWIProlog,
+        },
+        {
+            name: ".kb/ directory",
+            check: checkKbDirectory,
+        },
+        {
+            name: "config.json",
+            check: checkConfigJson,
+        },
+        {
+            name: "Git repository",
+            check: checkGitRepository,
+        },
+        {
+            name: "Git hooks",
+            check: checkGitHooks,
+        },
+        {
+            name: "pre-commit hook",
+            check: checkPreCommitHook,
+        },
+    ];
+    console.log("Kibi Environment Diagnostics\n");
+    let allPassed = true;
+    for (const { name, check } of checks) {
+        const result = check();
+        const status = result.passed ? "✓" : "✗";
+        console.log(`${status} ${name}: ${result.message}`);
+        if (!result.passed) {
+            allPassed = false;
+            if (result.remediation) {
+                console.log(`  → ${result.remediation}`);
+            }
+        }
+    }
+    console.log();
+    if (allPassed) {
+        console.log("All checks passed! Your environment is ready.");
+        process.exit(0);
+    }
+    else {
+        console.log("Some checks failed. Please address the issues above.");
+        process.exit(1);
+    }
+}
+function checkSWIProlog() {
+    try {
+        const output = execSync("swipl --version", { encoding: "utf-8" });
+        const versionMatch = output.match(/version\s+(\d+)\.(\d+)/i);
+        if (!versionMatch) {
+            return {
+                passed: false,
+                message: "Unable to parse version",
+                remediation: "Reinstall SWI-Prolog from https://www.swi-prolog.org/",
+            };
+        }
+        const major = Number.parseInt(versionMatch[1], 10);
+        if (major < 9) {
+            return {
+                passed: false,
+                message: `Version ${major}.x found (requires ≥9.0)`,
+                remediation: "Upgrade SWI-Prolog to version 9.0 or higher from https://www.swi-prolog.org/",
+            };
+        }
+        return {
+            passed: true,
+            message: `Version ${versionMatch[0]} installed`,
+        };
+    }
+    catch (error) {
+        return {
+            passed: false,
+            message: "Not installed or not in PATH",
+            remediation: "Install SWI-Prolog from https://www.swi-prolog.org/ and add to PATH",
+        };
+    }
+}
+function checkKbDirectory() {
+    const kbDir = path.join(process.cwd(), ".kb");
+    if (!existsSync(kbDir)) {
+        return {
+            passed: false,
+            message: "Not found",
+            remediation: "Run: kibi init",
+        };
+    }
+    return {
+        passed: true,
+        message: "Found",
+    };
+}
+function checkConfigJson() {
+    const configPath = path.join(process.cwd(), ".kb/config.json");
+    if (!existsSync(configPath)) {
+        return {
+            passed: false,
+            message: "Not found",
+            remediation: "Run: kibi init",
+        };
+    }
+    try {
+        const content = readFileSync(configPath, "utf-8");
+        JSON.parse(content);
+        return {
+            passed: true,
+            message: "Valid JSON",
+        };
+    }
+    catch (error) {
+        return {
+            passed: false,
+            message: "Invalid JSON",
+            remediation: "Fix .kb/config.json syntax or run: kibi init",
+        };
+    }
+}
+function checkGitRepository() {
+    try {
+        execSync("git status", { stdio: "pipe", cwd: process.cwd() });
+        return {
+            passed: true,
+            message: "Found",
+        };
+    }
+    catch (error) {
+        return {
+            passed: false,
+            message: "Not a git repository",
+            remediation: "Run: git init",
+        };
+    }
+}
+function checkGitHooks() {
+    const postCheckoutPath = path.join(process.cwd(), ".git/hooks/post-checkout");
+    const postMergePath = path.join(process.cwd(), ".git/hooks/post-merge");
+    const postCheckoutExists = existsSync(postCheckoutPath);
+    const postMergeExists = existsSync(postMergePath);
+    if (!postCheckoutExists && !postMergeExists) {
+        return {
+            passed: true,
+            message: "Not installed (optional)",
+        };
+    }
+    if (postCheckoutExists && postMergeExists) {
+        try {
+            const checkoutStats = statSync(postCheckoutPath);
+            const mergeStats = statSync(postMergePath);
+            const checkoutExecutable = (checkoutStats.mode & 0o111) !== 0;
+            const mergeExecutable = (mergeStats.mode & 0o111) !== 0;
+            if (checkoutExecutable && mergeExecutable) {
+                return {
+                    passed: true,
+                    message: "Installed and executable",
+                };
+            }
+            return {
+                passed: false,
+                message: "Installed but not executable",
+                remediation: "Run: chmod +x .git/hooks/post-checkout .git/hooks/post-merge",
+            };
+        }
+        catch (error) {
+            return {
+                passed: false,
+                message: "Unable to check hook permissions",
+            };
+        }
+    }
+    return {
+        passed: false,
+        message: "Partially installed",
+        remediation: "Run: kibi init --hooks",
+    };
+}
+function checkPreCommitHook() {
+    const postCheckoutPath = path.join(process.cwd(), ".git/hooks/post-checkout");
+    const postMergePath = path.join(process.cwd(), ".git/hooks/post-merge");
+    const preCommitPath = path.join(process.cwd(), ".git/hooks/pre-commit");
+    const postCheckoutExists = existsSync(postCheckoutPath);
+    const postMergeExists = existsSync(postMergePath);
+    if (!postCheckoutExists && !postMergeExists) {
+        return {
+            passed: true,
+            message: "Not installed (optional)",
+        };
+    }
+    const preCommitExists = existsSync(preCommitPath);
+    if (!preCommitExists) {
+        return {
+            passed: false,
+            message: "Not installed",
+            remediation: "Run: kibi init --hooks",
+        };
+    }
+    try {
+        const preCommitStats = statSync(preCommitPath);
+        const preCommitExecutable = (preCommitStats.mode & 0o111) !== 0;
+        if (preCommitExecutable) {
+            return {
+                passed: true,
+                message: "Installed and executable",
+            };
+        }
+        return {
+            passed: false,
+            message: "Installed but not executable",
+            remediation: "Run: chmod +x .git/hooks/pre-commit",
+        };
+    }
+    catch (error) {
+        return {
+            passed: false,
+            message: "Unable to check hook permissions",
+        };
+    }
+}

package/dist/commands/gc.d.ts

@@ -0,0 +1,6 @@
+export declare function gcCommand(options: {
+    dryRun?: boolean;
+    force?: boolean;
+}): Promise<void>;
+export default gcCommand;
+//# sourceMappingURL=gc.d.ts.map

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

@@ -0,0 +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"}

package/dist/commands/gc.js

@@ -0,0 +1,117 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+/*
+ How to apply this header to source files (examples)
+
+ 1) Prepend header to a single file (POSIX shells):
+
+    cat LICENSE_HEADER.txt "$FILE" > "$FILE".with-header && mv "$FILE".with-header "$FILE"
+
+ 2) Apply to multiple files (example: the project's main entry files):
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp packages/cli/src/*.ts packages/mcp/src/*.ts; do
+      if [ -f "$f" ]; then
+        cp "$f" "$f".bak
+        (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+      fi
+    done
+
+ 3) Avoid duplicating the header: run a quick guard to only add if missing
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp; do
+      if [ -f "$f" ]; then
+        if ! head -n 5 "$f" | grep -q "Copyright (C) 2026 Piotr Franczyk"; then
+          cp "$f" "$f".bak
+          (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+        fi
+      fi
+    done
+*/
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+export async function gcCommand(options) {
+    // If force is true, perform deletion. Otherwise default to dry run.
+    const dryRun = options?.force ? false : (options?.dryRun ?? true);
+    try {
+        const kbRoot = path.resolve(process.cwd(), ".kb/branches");
+        if (!fs.existsSync(kbRoot)) {
+            console.error("No branch KBs found (.kb/branches does not exist)");
+            process.exitCode = 1;
+            return;
+        }
+        let gitBranches;
+        try {
+            execSync("git rev-parse --git-dir", {
+                encoding: "utf-8",
+                cwd: process.cwd(),
+                stdio: ["pipe", "pipe", "pipe"],
+                env: process.env,
+            });
+            const output = execSync("git branch --format='%(refname:short)'", {
+                encoding: "utf-8",
+                cwd: process.cwd(),
+                stdio: ["pipe", "pipe", "pipe"],
+                env: process.env,
+            });
+            gitBranches = new Set(output
+                .trim()
+                .split("\n")
+                .map((b) => b.trim().replace(/^'|'$/g, ""))
+                .filter((b) => b));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Not in a git repository or git command failed: ${message}`);
+            process.exitCode = 1;
+            return;
+        }
+        const kbBranches = fs
+            .readdirSync(kbRoot, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name);
+        const staleBranches = kbBranches.filter((kb) => kb !== "main" && !gitBranches.has(kb));
+        // Perform deletion when dryRun is false (force requested)
+        const performDelete = !dryRun;
+        let deletedCount = 0;
+        if (performDelete && staleBranches.length > 0) {
+            for (const branch of staleBranches) {
+                const branchPath = path.join(kbRoot, branch);
+                fs.rmSync(branchPath, { recursive: true, force: true });
+                deletedCount++;
+            }
+        }
+        if (dryRun) {
+            console.log(`Found ${staleBranches.length} stale branch KB(s) (dry run - not deleted)`);
+            if (staleBranches.length > 0) {
+                for (const b of staleBranches)
+                    console.log(`  - ${b}`);
+            }
+        }
+        else {
+            console.log(`Deleted ${deletedCount} stale branch KB(s)`);
+        }
+        process.exitCode = 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Branch GC failed: ${message}`);
+        process.exitCode = 1;
+    }
+}
+export default gcCommand;

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

@@ -0,0 +1,8 @@
+export declare function getCurrentBranch(cwd?: string): Promise<string>;
+export declare function createKbDirectoryStructure(kbDir: string, currentBranch: string): void;
+export declare function createConfigFile(kbDir: string): void;
+export declare function updateGitIgnore(cwd: string): void;
+export declare function copySchemaFiles(kbDir: string, schemaSourceDir: string): Promise<void>;
+export declare function installHook(hookPath: string, content: string): void;
+export declare function installGitHooks(gitDir: string): void;
+//# sourceMappingURL=init-helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"init-helpers.d.ts","sourceRoot":"","sources":["../../src/commands/init-helpers.ts"],"names":[],"mappings":"AAiFA,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,CAqBnE;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAapD"}

package/dist/commands/init-helpers.js

@@ -0,0 +1,150 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+/*
+ How to apply this header to source files (examples)
+
+ 1) Prepend header to a single file (POSIX shells):
+
+    cat LICENSE_HEADER.txt "$FILE" > "$FILE".with-header && mv "$FILE".with-header "$FILE"
+
+ 2) Apply to multiple files (example: the project's main entry files):
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp packages/cli/src/*.ts packages/mcp/src/*.ts; do
+      if [ -f "$f" ]; then
+        cp "$f" "$f".bak
+        (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+      fi
+    done
+
+ 3) Avoid duplicating the header: run a quick guard to only add if missing
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp; do
+      if [ -f "$f" ]; then
+        if ! head -n 5 "$f" | grep -q "Copyright (C) 2026 Piotr Franczyk"; then
+          cp "$f" "$f".bak
+          (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+        fi
+      fi
+    done
+*/
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import * as path from "node:path";
+import fg from "fast-glob";
+const POST_CHECKOUT_HOOK = `#!/bin/sh
+kibi sync
+`;
+const POST_MERGE_HOOK = `#!/bin/sh
+kibi sync
+`;
+const PRE_COMMIT_HOOK = `#!/bin/sh
+set -e
+kibi check
+`;
+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";
+    }
+    return currentBranch;
+}
+export function createKbDirectoryStructure(kbDir, currentBranch) {
+    mkdirSync(kbDir, { recursive: true });
+    mkdirSync(path.join(kbDir, "schema"), { recursive: true });
+    mkdirSync(path.join(kbDir, "branches", currentBranch), {
+        recursive: true,
+    });
+    console.log("✓ Created .kb/ directory structure");
+    console.log(`✓ Created branches/${currentBranch}/ directory`);
+}
+export function createConfigFile(kbDir) {
+    writeFileSync(path.join(kbDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
+    console.log("✓ Created config.json with default paths");
+}
+export function updateGitIgnore(cwd) {
+    const gitignorePath = path.join(cwd, ".gitignore");
+    const gitignoreContent = existsSync(gitignorePath)
+        ? readFileSync(gitignorePath, "utf8")
+        : "";
+    if (!gitignoreContent.includes(".kb/")) {
+        const newContent = gitignoreContent
+            ? `${gitignoreContent.trimEnd()}\n.kb/\n`
+            : ".kb/\n";
+        writeFileSync(gitignorePath, newContent);
+        console.log("✓ Added .kb/ to .gitignore");
+    }
+}
+export async function copySchemaFiles(kbDir, schemaSourceDir) {
+    const schemaFiles = await fg("*.pl", {
+        cwd: schemaSourceDir,
+        absolute: false,
+    });
+    for (const file of schemaFiles) {
+        const sourcePath = path.join(schemaSourceDir, file);
+        const destPath = path.join(kbDir, "schema", file);
+        copyFileSync(sourcePath, destPath);
+    }
+    console.log(`✓ Copied ${schemaFiles.length} schema files`);
+}
+export function installHook(hookPath, content) {
+    if (existsSync(hookPath)) {
+        const existing = readFileSync(hookPath, "utf8");
+        if (!existing.includes("kibi")) {
+            writeFileSync(hookPath, `${existing}
+${content}`, {
+                mode: 0o755,
+            });
+        }
+    }
+    else {
+        writeFileSync(hookPath, `#!/bin/sh
+${content}`, { mode: 0o755 });
+    }
+}
+export function installGitHooks(gitDir) {
+    const hooksDir = path.join(gitDir, "hooks");
+    mkdirSync(hooksDir, { recursive: true });
+    const postCheckoutPath = path.join(hooksDir, "post-checkout");
+    const postMergePath = path.join(hooksDir, "post-merge");
+    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(preCommitPath, PRE_COMMIT_HOOK.replace("#!/bin/sh\n", ""));
+    console.log("✓ Installed git hooks (pre-commit, post-checkout, post-merge)");
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,6 @@
+interface InitOptions {
+    hooks?: boolean;
+}
+export declare function initCommand(options: InitOptions): Promise<void>;
+export {};
+//# sourceMappingURL=init.d.ts.map

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

@@ -0,0 +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"}

package/dist/commands/init.js

@@ -0,0 +1,85 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+/*
+ How to apply this header to source files (examples)
+
+ 1) Prepend header to a single file (POSIX shells):
+
+    cat LICENSE_HEADER.txt "$FILE" > "$FILE".with-header && mv "$FILE".with-header "$FILE"
+
+ 2) Apply to multiple files (example: the project's main entry files):
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp packages/cli/src/*.ts packages/mcp/src/*.ts; do
+      if [ -f "$f" ]; then
+        cp "$f" "$f".bak
+        (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+      fi
+    done
+
+ 3) Avoid duplicating the header: run a quick guard to only add if missing
+
+    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp; do
+      if [ -f "$f" ]; then
+        if ! head -n 5 "$f" | grep -q "Copyright (C) 2026 Piotr Franczyk"; then
+          cp "$f" "$f".bak
+          (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
+        fi
+      fi
+    done
+*/
+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";
+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();
+    try {
+        if (!kbExists) {
+            createKbDirectoryStructure(kbDir, currentBranch);
+            createConfigFile(kbDir);
+            updateGitIgnore(process.cwd());
+            const schemaSourceDir = path.resolve(__dirname, "..", "..", "schema");
+            await copySchemaFiles(kbDir, schemaSourceDir);
+        }
+        else {
+            console.log("✓ .kb/ directory already exists, skipping creation");
+        }
+        if (options.hooks) {
+            const gitDir = path.join(process.cwd(), ".git");
+            if (!existsSync(gitDir)) {
+                console.error("Warning: No git repository found, skipping hooks");
+            }
+            else {
+                installGitHooks(gitDir);
+            }
+        }
+        console.log("\nKibi initialized successfully!");
+        console.log("Next steps:");
+        console.log("  1. Run 'kibi doctor' to verify setup");
+        console.log("  2. Run 'kibi sync' to extract entities from documents");
+        process.exit(0);
+    }
+    catch (error) {
+        console.error("Error during initialization:", error);
+        process.exit(1);
+    }
+}

package/dist/commands/query.d.ts

@@ -0,0 +1,12 @@
+interface QueryOptions {
+    id?: string;
+    tag?: string;
+    source?: string;
+    relationships?: string;
+    format?: "json" | "table";
+    limit?: string;
+    offset?: string;
+}
+export declare function queryCommand(type: string | undefined, options: QueryOptions): Promise<void>;
+export {};
+//# sourceMappingURL=query.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/commands/query.ts"],"names":[],"mappings":"AAiDA,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,CA2Jf"}