@cliperhq/cliper 1.0.0

package/dist/commands/init.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const dependencies_1 = require("../scanner/dependencies");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const simple_git_1 = __importDefault(require("simple-git"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const autoScope_1 = require("../scope/autoScope");
+const config_1 = require("../scope/config");
+const fileTree_1 = require("../scanner/fileTree");
+const fileContent_1 = require("../scanner/fileContent");
+const gitContext_1 = require("../scanner/gitContext");
+const urlFetcher_1 = require("../resolver/urlFetcher");
+const detector_1 = require("../gaps/detector");
+const builder_1 = require("../context/builder");
+async function initCommand(options) {
+    const projectRoot = path.resolve(options.path);
+    if (!fs.existsSync(projectRoot)) {
+        console.error(chalk_1.default.red(`Project path not found: ${projectRoot}`));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.bold.cyan("\n  cliper init\n"));
+    console.log(chalk_1.default.gray(`  Project: ${projectRoot}\n`));
+    // Step 1: Load or create scope config
+    const spinner = (0, ora_1.default)("Detecting scope from git activity...").start();
+    let scopeConfig = (0, config_1.loadScopeConfig)(projectRoot);
+    // Always re-run auto-detection and merge with any manual additions
+    const autoScope = await (0, autoScope_1.autoDetectScope)(projectRoot);
+    const manualAdditions = scopeConfig.active.filter((p) => !autoScope.includes(p));
+    scopeConfig.active = [...new Set([...autoScope, ...manualAdditions])];
+    (0, config_1.saveScopeConfig)(projectRoot, scopeConfig);
+    spinner.succeed(chalk_1.default.green(`Scope detected: ${scopeConfig.active.length} paths active, ${scopeConfig.watched.length} watched`));
+    // Step 2: Generate file tree
+    const treeSpinner = (0, ora_1.default)("Building annotated file tree...").start();
+    const fileTree = (0, fileTree_1.generateFileTree)(projectRoot, scopeConfig.active, scopeConfig.watched);
+    treeSpinner.succeed(chalk_1.default.green("File tree built"));
+    // Step 3: Extract file contents
+    const contentSpinner = (0, ora_1.default)("Extracting file contents within scope...").start();
+    const files = await (0, fileContent_1.extractFileContents)(projectRoot, scopeConfig.active, scopeConfig.watched, options.maxFileSize ?? 50);
+    contentSpinner.succeed(chalk_1.default.green(`Extracted ${files.length} files`));
+    // Step 4: Git context
+    const gitSpinner = (0, ora_1.default)("Reading git context...").start();
+    const gitContext = await (0, gitContext_1.getGitContext)(projectRoot);
+    gitSpinner.succeed(gitContext.isGitRepo
+        ? chalk_1.default.green(`Git: ${gitContext.branch} — ${gitContext.lastCommit?.message ?? "no commits"}`)
+        : chalk_1.default.yellow("Not a git repository"));
+    // Step 5: Resolve blocked references
+    const refSpinner = (0, ora_1.default)("Fetching blocked external references...").start();
+    const references = await (0, urlFetcher_1.resolveBlockedReferences)(projectRoot);
+    const fetched = references.filter((r) => r.status === "fetched").length;
+    const failed = references.filter((r) => r.status === "failed").length;
+    refSpinner.succeed(chalk_1.default.green(`References: ${fetched} fetched, ${failed} failed`));
+    // Step 6: Detect gaps
+    const gapSpinner = (0, ora_1.default)("Detecting gaps and undocumented patterns...").start();
+    const gaps = (0, detector_1.detectGaps)(files, projectRoot);
+    gapSpinner.succeed(gaps.length > 0
+        ? chalk_1.default.yellow(`Found ${gaps.length} gaps (${gaps.filter((g) => g.severity === "high").length} high priority)`)
+        : chalk_1.default.green("No significant gaps detected"));
+    const depSpinner = (0, ora_1.default)("Mapping dependencies...").start();
+    const dependencyMap = (0, dependencies_1.buildDependencyMap)(files);
+    depSpinner.succeed(chalk_1.default.green(`Dependency map: ${dependencyMap.edges.length} edges, ${dependencyMap.externalPackages.length} external packages`));
+    // Step 7: Build context doc
+    const buildSpinner = (0, ora_1.default)("Building context document...").start();
+    const projectName = path.basename(projectRoot);
+    const contextDoc = (0, builder_1.buildContextDoc)({
+        projectRoot,
+        projectName,
+        activeScope: scopeConfig.active,
+        watchedScope: scopeConfig.watched,
+        fileTree,
+        files,
+        gitContext,
+        references,
+        gaps,
+        generatedAt: new Date().toISOString(),
+        dependencyMap: (0, dependencies_1.formatDependencyMap)(dependencyMap),
+    });
+    // Step 8: Write to disk
+    const cliperDir = (0, config_1.getCliperDir)(projectRoot);
+    if (!fs.existsSync(cliperDir))
+        fs.mkdirSync(cliperDir, { recursive: true });
+    const contextPath = path.join(cliperDir, "context.md");
+    fs.writeFileSync(contextPath, contextDoc, "utf-8");
+    buildSpinner.succeed(chalk_1.default.green("Context document built"));
+    // Auto-manage .gitignore — add anything cliper introduces that shouldn't be committed
+    const gitignorePath = path.join(projectRoot, ".gitignore");
+    const entriesToEnsure = [
+        { check: "node_modules", line: "node_modules/" },
+        { check: "package-lock.json", line: "package-lock.json" },
+        { check: ".cliper/cache", line: ".cliper/cache/" },
+        { check: ".cliper/prompt-", line: ".cliper/prompt-*.md" },
+    ];
+    let gitignoreContent = fs.existsSync(gitignorePath)
+        ? fs.readFileSync(gitignorePath, "utf-8")
+        : "";
+    const missingEntries = entriesToEnsure.filter((e) => !gitignoreContent.includes(e.check));
+    if (missingEntries.length > 0) {
+        const block = "\n# Cliper — auto-managed\n" + missingEntries.map((e) => e.line).join("\n") + "\n";
+        if (fs.existsSync(gitignorePath)) {
+            fs.appendFileSync(gitignorePath, block);
+        }
+        else {
+            fs.writeFileSync(gitignorePath, block.trimStart());
+        }
+    }
+    // Remove node_modules from git tracking if accidentally staged
+    try {
+        const gitInstance = (0, simple_git_1.default)(projectRoot);
+        const tracked = await gitInstance.raw(["ls-files", "node_modules"]);
+        if (tracked.trim().length > 0) {
+            await gitInstance.raw(["rm", "-r", "--cached", "node_modules/"]);
+            console.log(chalk_1.default.yellow("  ⚡ Removed node_modules from git tracking"));
+        }
+        const lockTracked = await gitInstance.raw(["ls-files", "package-lock.json"]);
+        if (lockTracked.trim().length > 0) {
+            await gitInstance.raw(["rm", "--cached", "package-lock.json"]);
+            console.log(chalk_1.default.yellow("  ⚡ Removed package-lock.json from git tracking"));
+        }
+    }
+    catch {
+        // Not a git repo or already clean — skip silently
+    }
+    // Summary
+    const sizeKB = Math.round(Buffer.byteLength(contextDoc, "utf-8") / 1024);
+    const estimatedTokens = Math.round(contextDoc.length / 4);
+    console.log(chalk_1.default.bold.green("\n  ✓ Context document ready\n"));
+    console.log(chalk_1.default.gray(`  Location:  ${contextPath}`));
+    console.log(chalk_1.default.gray(`  Size:      ${sizeKB}KB (~${estimatedTokens.toLocaleString()} tokens)`));
+    console.log(chalk_1.default.gray(`  Files:     ${files.length} files in context`));
+    console.log(chalk_1.default.gray(`  Gaps:      ${gaps.length} detected\n`));
+    console.log(chalk_1.default.cyan("  Copy to clipboard:"));
+    console.log(chalk_1.default.white("    cliper export | pbcopy        # macOS"));
+    console.log(chalk_1.default.white("    cliper export | xclip         # Linux\n"));
+}
+//# sourceMappingURL=init.js.map

package/dist/commands/scope.d.ts

@@ -0,0 +1,2 @@
+export declare function scopeCommand(action: string, scopePath?: string): Promise<void>;
+//# sourceMappingURL=scope.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../src/commands/scope.ts"],"names":[],"mappings":"AAIA,wBAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAwEpF"}

package/dist/commands/scope.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scopeCommand = scopeCommand;
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../scope/config");
+async function scopeCommand(action, scopePath) {
+    const projectRoot = process.cwd();
+    const config = (0, config_1.loadScopeConfig)(projectRoot);
+    switch (action) {
+        case "add": {
+            if (!scopePath) {
+                console.error(chalk_1.default.red("  Please provide a path."));
+                process.exit(1);
+            }
+            const normalized = path.normalize(scopePath);
+            if (!config.active.includes(normalized)) {
+                config.active.push(normalized);
+                (0, config_1.saveScopeConfig)(projectRoot, config);
+                console.log(chalk_1.default.green(`\n  ✓ Added to active scope: ${normalized}\n`));
+                console.log(chalk_1.default.gray("  Run cliper sync to update the context doc.\n"));
+            }
+            else {
+                console.log(chalk_1.default.yellow(`\n  Already in scope: ${normalized}\n`));
+            }
+            break;
+        }
+        case "watch": {
+            if (!scopePath) {
+                console.error(chalk_1.default.red("  Please provide a path."));
+                process.exit(1);
+            }
+            const normalized = path.normalize(scopePath);
+            if (config.watched.length >= 15) {
+                console.log(chalk_1.default.yellow("\n  Watch list is capped at 15 files. Remove one first:\n"));
+                console.log(chalk_1.default.gray("  cliper scope remove <path>\n"));
+                process.exit(1);
+            }
+            if (!config.watched.includes(normalized)) {
+                config.watched.push(normalized);
+                (0, config_1.saveScopeConfig)(projectRoot, config);
+                console.log(chalk_1.default.green(`\n  ✓ Added to watch list: ${normalized}\n`));
+            }
+            else {
+                console.log(chalk_1.default.yellow(`\n  Already watched: ${normalized}\n`));
+            }
+            break;
+        }
+        case "remove": {
+            if (!scopePath) {
+                console.error(chalk_1.default.red("  Please provide a path."));
+                process.exit(1);
+            }
+            const normalized = path.normalize(scopePath);
+            config.active = config.active.filter((p) => p !== normalized);
+            config.watched = config.watched.filter((p) => p !== normalized);
+            (0, config_1.saveScopeConfig)(projectRoot, config);
+            console.log(chalk_1.default.green(`\n  ✓ Removed from scope: ${normalized}\n`));
+            break;
+        }
+        case "list": {
+            console.log(chalk_1.default.bold.cyan("\n  Current Scope\n"));
+            if (config.active.length === 0 && config.watched.length === 0) {
+                console.log(chalk_1.default.gray("  No scope configured. Run cliper init to auto-detect.\n"));
+                break;
+            }
+            if (config.active.length > 0) {
+                console.log(chalk_1.default.bold("  Active scope:"));
+                for (const p of config.active)
+                    console.log(chalk_1.default.white(`    • ${p}`));
+            }
+            if (config.watched.length > 0) {
+                console.log(chalk_1.default.bold("\n  Watch list:"));
+                for (const p of config.watched)
+                    console.log(chalk_1.default.white(`    • ${p}`));
+                console.log(chalk_1.default.gray(`\n  (${config.watched.length}/15 watch slots used)`));
+            }
+            console.log();
+            break;
+        }
+        default: {
+            console.error(chalk_1.default.red(`\n  Unknown action: ${action}`));
+            console.log(chalk_1.default.gray("  Usage: cliper scope <add|remove|watch|list> [path]\n"));
+            process.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=scope.js.map

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+export declare function statusCommand(): Promise<void>;
+//# sourceMappingURL=status.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.ts"],"names":[],"mappings":"AAMA,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CA4DnD"}

package/dist/commands/status.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = statusCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../scope/config");
+const gitContext_1 = require("../scanner/gitContext");
+async function statusCommand() {
+    const projectRoot = process.cwd();
+    const cliperDir = (0, config_1.getCliperDir)(projectRoot);
+    const contextPath = path.join(cliperDir, "context.md");
+    const config = (0, config_1.loadScopeConfig)(projectRoot);
+    console.log(chalk_1.default.bold.cyan("\n  cliper status\n"));
+    // Context doc status
+    if (!fs.existsSync(contextPath)) {
+        console.log(chalk_1.default.red("  ✗ No context doc found"));
+        console.log(chalk_1.default.gray("    Run: cliper init\n"));
+        return;
+    }
+    const stat = fs.statSync(contextPath);
+    const ageMs = Date.now() - stat.mtime.getTime();
+    const ageHours = Math.floor(ageMs / 3600000);
+    const ageMins = Math.floor(ageMs / 60000);
+    const ageStr = ageHours > 0 ? `${ageHours}h ago` : `${ageMins}m ago`;
+    const sizeKB = Math.round(stat.size / 1024);
+    const isFresh = ageMs < 3600000; // < 1 hour
+    console.log(isFresh
+        ? chalk_1.default.green(`  ✓ Context doc is fresh`)
+        : chalk_1.default.yellow(`  ⚡ Context doc may be stale`));
+    console.log(chalk_1.default.gray(`    Last updated: ${ageStr} | Size: ${sizeKB}KB`));
+    console.log(chalk_1.default.gray(`    Path: ${contextPath}`));
+    // Scope status
+    console.log(chalk_1.default.bold("\n  Scope:"));
+    if (config.active.length === 0) {
+        console.log(chalk_1.default.gray("    No active scope. Run cliper init to auto-detect."));
+    }
+    else {
+        for (const p of config.active)
+            console.log(chalk_1.default.white(`    • ${p}  `) + chalk_1.default.cyan("[active]"));
+        for (const p of config.watched)
+            console.log(chalk_1.default.white(`    • ${p}  `) + chalk_1.default.blue("[watched]"));
+    }
+    // Git status
+    const git = await (0, gitContext_1.getGitContext)(projectRoot);
+    if (git.isGitRepo) {
+        console.log(chalk_1.default.bold("\n  Git:"));
+        console.log(chalk_1.default.gray(`    Branch:  ${git.branch}`));
+        if (git.lastCommit) {
+            console.log(chalk_1.default.gray(`    Latest:  ${git.lastCommit.hash} — ${git.lastCommit.message} (${git.lastCommit.timeAgo})`));
+        }
+        if (git.uncommittedChanges.length > 0) {
+            console.log(chalk_1.default.yellow(`    Uncommitted: ${git.uncommittedChanges.length} files changed`));
+            if (ageMs > 600000) {
+                // Context is older than 10 mins and there are uncommitted changes
+                console.log(chalk_1.default.yellow("\n  ⚡ Changes detected since last context update."));
+                console.log(chalk_1.default.gray("    Run: cliper sync\n"));
+                return;
+            }
+        }
+    }
+    console.log();
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/sync.d.ts

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

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

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

package/dist/commands/sync.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncCommand = syncCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const config_1 = require("../scope/config");
+const init_1 = require("./init");
+async function syncCommand(options) {
+    const projectRoot = process.cwd();
+    const contextPath = path.join((0, config_1.getCliperDir)(projectRoot), "context.md");
+    if (!fs.existsSync(contextPath)) {
+        console.log(chalk_1.default.yellow("\n  No context doc found. Run cliper init first.\n"));
+        process.exit(1);
+    }
+    if (options.watch) {
+        console.log(chalk_1.default.cyan("\n  Watching for git changes... (Ctrl+C to stop)\n"));
+        let lastHash = "";
+        const check = async () => {
+            try {
+                const { default: simpleGit } = await Promise.resolve().then(() => __importStar(require("simple-git")));
+                const git = simpleGit(projectRoot);
+                const log = await git.log({ maxCount: 1 });
+                const currentHash = log.latest?.hash ?? "";
+                if (currentHash && currentHash !== lastHash) {
+                    if (lastHash !== "") {
+                        console.log(chalk_1.default.yellow(`\n  New commit detected: ${currentHash.slice(0, 7)} — refreshing context...\n`));
+                        await (0, init_1.initCommand)({ path: projectRoot });
+                    }
+                    lastHash = currentHash;
+                }
+            }
+            catch {
+                // silently skip
+            }
+        };
+        await check();
+        setInterval(check, 10000); // Check every 10 seconds
+    }
+    else {
+        const spinner = (0, ora_1.default)("Syncing context document...").start();
+        spinner.stop();
+        await (0, init_1.initCommand)({ path: projectRoot });
+    }
+}
+//# sourceMappingURL=sync.js.map

package/dist/context/builder.d.ts

@@ -0,0 +1,19 @@
+import { FileContent } from "../scanner/fileContent";
+import { GitContext } from "../scanner/gitContext";
+import { ResolvedReference } from "../resolver/urlFetcher";
+import { Gap } from "../gaps/detector";
+export interface ContextDocOptions {
+    projectRoot: string;
+    projectName: string;
+    activeScope: string[];
+    watchedScope: string[];
+    fileTree: string;
+    files: FileContent[];
+    gitContext: GitContext;
+    references: ResolvedReference[];
+    gaps: Gap[];
+    generatedAt: string;
+    dependencyMap: string;
+}
+export declare function buildContextDoc(opts: ContextDocOptions): string;
+//# sourceMappingURL=builder.d.ts.map

package/dist/context/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/context/builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAEvC,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,EAAE,iBAAiB,EAAE,CAAC;IAChC,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACvB;AAyGD,wBAAgB,eAAe,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAuD/D"}

package/dist/context/builder.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildContextDoc = buildContextDoc;
+const DIVIDER = "━".repeat(50);
+function formatGitContext(git) {
+    if (!git.isGitRepo)
+        return "Not a git repository.";
+    const lines = [];
+    lines.push(`Branch:        ${git.branch}`);
+    if (git.lastCommit) {
+        lines.push(`Last commit:   ${git.lastCommit.hash} — ${git.lastCommit.message} (${git.lastCommit.timeAgo})`);
+        lines.push(`Author:        ${git.lastCommit.author}`);
+    }
+    if (git.uncommittedChanges.length > 0) {
+        lines.push(`\nUncommitted changes (${git.uncommittedChanges.length} files):`);
+        for (const f of git.uncommittedChanges.slice(0, 10)) {
+            lines.push(`  - ${f}`);
+        }
+    }
+    if (git.recentCommits.length > 0) {
+        lines.push("\nRecent commits:");
+        for (const c of git.recentCommits) {
+            lines.push(`  ${c.hash} — ${c.message}`);
+        }
+    }
+    return lines.join("\n");
+}
+function formatFileContents(files) {
+    if (files.length === 0)
+        return "No files in scope.";
+    return files
+        .map((f) => {
+        const ext = f.relativePath.split(".").pop() ?? "";
+        const truncatedNote = f.truncated ? "\n[... truncated ...]" : "";
+        return `### ${f.relativePath}\n\`\`\`${ext}\n${f.content}${truncatedNote}\n\`\`\``;
+    })
+        .join("\n\n");
+}
+function formatReferences(refs) {
+    const fetched = refs.filter((r) => r.status === "fetched");
+    const failed = refs.filter((r) => r.status === "failed");
+    const lines = [];
+    if (fetched.length === 0 && failed.length === 0) {
+        return "No external references found in markdown files.";
+    }
+    for (const ref of fetched) {
+        lines.push(`#### ${ref.url}`);
+        lines.push(`Source: ${ref.source}`);
+        lines.push(`\n${ref.content}\n`);
+    }
+    if (failed.length > 0) {
+        lines.push("\n**Could not fetch:**");
+        for (const ref of failed) {
+            lines.push(`  - ${ref.url} (${ref.reason})`);
+        }
+    }
+    return lines.join("\n");
+}
+function formatGaps(gaps) {
+    if (gaps.length === 0)
+        return "No significant gaps detected.";
+    const bySeverity = {
+        high: gaps.filter((g) => g.severity === "high"),
+        medium: gaps.filter((g) => g.severity === "medium"),
+        low: gaps.filter((g) => g.severity === "low"),
+    };
+    const lines = [];
+    if (bySeverity.high.length > 0) {
+        lines.push("**HIGH PRIORITY**");
+        for (const g of bySeverity.high) {
+            lines.push(`  ⚠️  [${g.file}${g.line ? `:${g.line}` : ""}] ${g.description}`);
+        }
+    }
+    if (bySeverity.medium.length > 0) {
+        lines.push("\n**MEDIUM PRIORITY**");
+        for (const g of bySeverity.medium) {
+            lines.push(`  ⚡ [${g.file}${g.line ? `:${g.line}` : ""}] ${g.description}`);
+        }
+    }
+    if (bySeverity.low.length > 0) {
+        lines.push("\n**LOW PRIORITY**");
+        for (const g of bySeverity.low.slice(0, 10)) {
+            lines.push(`  ℹ️  [${g.file}${g.line ? `:${g.line}` : ""}] ${g.description}`);
+        }
+    }
+    return lines.join("\n");
+}
+function buildContextDoc(opts) {
+    const scopeSummary = [
+        ...opts.activeScope.map((s) => `${s} (active)`),
+        ...opts.watchedScope.map((s) => `${s} (watched)`),
+    ].join(", ") || "auto-detected";
+    return `${DIVIDER}
+CLIPER CONTEXT DOCUMENT
+${DIVIDER}
+PROJECT:      ${opts.projectName}
+GENERATED:    ${opts.generatedAt}
+BRANCH:       ${opts.gitContext.branch || "unknown"}
+SCOPED TO:    ${scopeSummary}
+${DIVIDER}
+
+## FOLDER STRUCTURE
+
+\`\`\`
+${opts.fileTree}
+\`\`\`
+
+${DIVIDER}
+
+## GIT CONTEXT
+
+${formatGitContext(opts.gitContext)}
+
+${DIVIDER}
+
+## DEPENDENCY MAP
+
+${opts.dependencyMap}
+
+${DIVIDER}
+
+## KEY FILES
+
+${formatFileContents(opts.files)}
+
+${DIVIDER}
+
+## BLOCKED REFERENCES (fetched locally)
+
+${formatReferences(opts.references)}
+
+${DIVIDER}
+
+## DETECTED GAPS
+
+${formatGaps(opts.gaps)}
+
+${DIVIDER}
+END OF CLIPER CONTEXT DOCUMENT
+${DIVIDER}
+`;
+}
+//# sourceMappingURL=builder.js.map