@cliperhq/cliper 1.0.0

package/dist/scanner/fileContent.js

@@ -0,0 +1,133 @@
+"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.extractFileContents = extractFileContents;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const glob_1 = require("glob");
+const ignore_1 = __importDefault(require("ignore"));
+const MAX_TOTAL_CHARS = 150000;
+const BINARY_EXTENSIONS = new Set([
+    ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico", ".webp",
+    ".pdf", ".zip", ".tar", ".gz", ".exe", ".bin", ".wasm",
+    ".ttf", ".woff", ".woff2", ".eot", ".mp4", ".mp3",
+]);
+const PRIORITY_EXTENSIONS = [
+    ".ts", ".tsx", ".js", ".jsx", ".py", ".rs", ".go",
+    ".java", ".kt", ".swift", ".rb", ".php", ".cs",
+    ".json", ".yaml", ".yml", ".toml", ".env.example",
+    ".md", ".mdx", ".sql", ".graphql", ".prisma",
+];
+function isBinary(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return BINARY_EXTENSIONS.has(ext);
+}
+function getPriority(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const idx = PRIORITY_EXTENSIONS.indexOf(ext);
+    return idx === -1 ? 999 : idx;
+}
+async function extractFileContents(projectRoot, activeScope, watchedScope, maxFileSizeKB = 50) {
+    const MAX_FILE_SIZE_BYTES = maxFileSizeKB * 1024;
+    const ig = (0, ignore_1.default)();
+    const gitignorePath = path.join(projectRoot, ".gitignore");
+    if (fs.existsSync(gitignorePath)) {
+        ig.add(fs.readFileSync(gitignorePath, "utf-8"));
+    }
+    const allPaths = new Set();
+    // Collect files from active scope and watched scope
+    for (const scopePath of [...activeScope, ...watchedScope]) {
+        const fullScopePath = path.join(projectRoot, scopePath);
+        if (!fs.existsSync(fullScopePath))
+            continue;
+        const stat = fs.statSync(fullScopePath);
+        if (stat.isFile()) {
+            allPaths.add(scopePath);
+        }
+        else if (stat.isDirectory()) {
+            const files = await (0, glob_1.glob)("**/*", {
+                cwd: fullScopePath,
+                nodir: true,
+                ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
+            });
+            for (const f of files) {
+                const rel = path.join(scopePath, f);
+                if (!ig.ignores(rel))
+                    allPaths.add(rel);
+            }
+        }
+    }
+    // Sort by priority
+    const sortedPaths = Array.from(allPaths).sort((a, b) => getPriority(a) - getPriority(b));
+    const results = [];
+    let totalChars = 0;
+    for (const relativePath of sortedPaths) {
+        if (totalChars >= MAX_TOTAL_CHARS)
+            break;
+        if (isBinary(relativePath))
+            continue;
+        const fullPath = path.join(projectRoot, relativePath);
+        if (!fs.existsSync(fullPath))
+            continue;
+        const stat = fs.statSync(fullPath);
+        if (stat.size > MAX_FILE_SIZE_BYTES) {
+            results.push({
+                relativePath,
+                content: `[File too large to include: ${Math.round(stat.size / 1024)}KB]`,
+                truncated: true,
+                size: stat.size,
+            });
+            continue;
+        }
+        try {
+            let content = fs.readFileSync(fullPath, "utf-8");
+            let truncated = false;
+            if (totalChars + content.length > MAX_TOTAL_CHARS) {
+                content = content.slice(0, MAX_TOTAL_CHARS - totalChars);
+                truncated = true;
+            }
+            totalChars += content.length;
+            results.push({ relativePath, content, truncated, size: stat.size });
+        }
+        catch {
+            // Skip files that can't be read
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=fileContent.js.map

package/dist/scanner/fileTree.d.ts

@@ -0,0 +1,2 @@
+export declare function generateFileTree(projectRoot: string, activeScope: string[], watchedScope: string[]): string;
+//# sourceMappingURL=fileTree.d.ts.map

package/dist/scanner/fileTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileTree.d.ts","sourceRoot":"","sources":["../../src/scanner/fileTree.ts"],"names":[],"mappings":"AA0IA,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EAAE,EACrB,YAAY,EAAE,MAAM,EAAE,GACrB,MAAM,CAMR"}

package/dist/scanner/fileTree.js

@@ -0,0 +1,152 @@
+"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.generateFileTree = generateFileTree;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ignore_1 = __importDefault(require("ignore"));
+const IGNORE_DIRS = new Set([
+    "node_modules", ".git", "dist", "build", ".next", ".nuxt",
+    "coverage", ".cache", "__pycache__", ".pytest_cache", "vendor",
+    ".cliper",
+]);
+function loadGitignore(projectRoot) {
+    const ig = (0, ignore_1.default)();
+    const gitignorePath = path.join(projectRoot, ".gitignore");
+    if (fs.existsSync(gitignorePath)) {
+        ig.add(fs.readFileSync(gitignorePath, "utf-8"));
+    }
+    return ig;
+}
+function getModifiedTime(filePath) {
+    try {
+        return fs.statSync(filePath).mtime;
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildTree(dirPath, projectRoot, activeScope, watchedScope, ig, depth = 0, maxDepth = 4) {
+    if (depth > maxDepth)
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const nodes = [];
+    for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        const relativePath = path.relative(projectRoot, fullPath);
+        if (IGNORE_DIRS.has(entry.name))
+            continue;
+        if (ig.ignores(relativePath))
+            continue;
+        if (entry.name.startsWith(".") && entry.name !== ".env.example")
+            continue;
+        const inScope = activeScope.some((s) => relativePath.startsWith(s) || s.startsWith(relativePath));
+        const watched = watchedScope.some((s) => relativePath.startsWith(s) || relativePath === s);
+        const node = {
+            name: entry.name,
+            isDir: entry.isDirectory(),
+            inScope,
+            watched,
+            relativePath,
+            modifiedAt: entry.isFile() ? getModifiedTime(fullPath) : undefined,
+        };
+        if (entry.isDirectory()) {
+            node.children = buildTree(fullPath, projectRoot, activeScope, watchedScope, ig, depth + 1, maxDepth);
+        }
+        nodes.push(node);
+    }
+    return nodes.sort((a, b) => {
+        if (a.isDir !== b.isDir)
+            return a.isDir ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    });
+}
+function formatTimeAgo(date) {
+    const diff = Date.now() - date.getTime();
+    const mins = Math.floor(diff / 60000);
+    const hours = Math.floor(diff / 3600000);
+    const days = Math.floor(diff / 86400000);
+    if (mins < 60)
+        return `${mins}m ago`;
+    if (hours < 24)
+        return `${hours}h ago`;
+    return `${days}d ago`;
+}
+function renderTree(nodes, prefix = "", isRoot = false) {
+    const lines = [];
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const isLast = i === nodes.length - 1;
+        const connector = isLast ? "└── " : "├── ";
+        const childPrefix = prefix + (isLast ? "    " : "│   ");
+        let annotation = "";
+        if (node.inScope)
+            annotation += " ← ACTIVE SCOPE";
+        else if (node.watched)
+            annotation += " ← WATCHED";
+        let timeAnnotation = "";
+        if (node.modifiedAt && !node.isDir) {
+            timeAnnotation = ` (${formatTimeAgo(node.modifiedAt)})`;
+        }
+        if (node.isDir && !node.inScope && !node.watched && !isRoot) {
+            const childCount = node.children?.length ?? 0;
+            lines.push(`${prefix}${connector}${node.name}/${annotation || ` ← out of scope (${childCount} items)`}`);
+        }
+        else {
+            lines.push(`${prefix}${connector}${node.name}${node.isDir ? "/" : ""}${annotation}${timeAnnotation}`);
+            if (node.children && node.children.length > 0 && (node.inScope || node.watched || isRoot)) {
+                lines.push(renderTree(node.children, childPrefix));
+            }
+        }
+    }
+    return lines.filter(Boolean).join("\n");
+}
+function generateFileTree(projectRoot, activeScope, watchedScope) {
+    const ig = loadGitignore(projectRoot);
+    const projectName = path.basename(projectRoot);
+    const nodes = buildTree(projectRoot, projectRoot, activeScope, watchedScope, ig, 0);
+    const tree = renderTree(nodes, "", true);
+    return `${projectName}/\n${tree}`;
+}
+//# sourceMappingURL=fileTree.js.map

package/dist/scanner/gitContext.d.ts

@@ -0,0 +1,19 @@
+export interface GitContext {
+    branch: string;
+    lastCommit: {
+        hash: string;
+        message: string;
+        author: string;
+        date: string;
+        timeAgo: string;
+    } | null;
+    recentCommits: Array<{
+        hash: string;
+        message: string;
+        date: string;
+    }>;
+    uncommittedChanges: string[];
+    isGitRepo: boolean;
+}
+export declare function getGitContext(projectRoot: string): Promise<GitContext>;
+//# sourceMappingURL=gitContext.d.ts.map

package/dist/scanner/gitContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gitContext.d.ts","sourceRoot":"","sources":["../../src/scanner/gitContext.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE;QACV,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,GAAG,IAAI,CAAC;IACT,aAAa,EAAE,KAAK,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;IACH,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,SAAS,EAAE,OAAO,CAAC;CACpB;AAYD,wBAAsB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA2C5E"}

package/dist/scanner/gitContext.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitContext = getGitContext;
+const simple_git_1 = __importDefault(require("simple-git"));
+function timeAgo(dateStr) {
+    const diff = Date.now() - new Date(dateStr).getTime();
+    const mins = Math.floor(diff / 60000);
+    const hours = Math.floor(diff / 3600000);
+    const days = Math.floor(diff / 86400000);
+    if (mins < 60)
+        return `${mins} minutes ago`;
+    if (hours < 24)
+        return `${hours} hours ago`;
+    return `${days} days ago`;
+}
+async function getGitContext(projectRoot) {
+    const git = (0, simple_git_1.default)(projectRoot);
+    try {
+        const isRepo = await git.checkIsRepo();
+        if (!isRepo) {
+            return { branch: "", lastCommit: null, recentCommits: [], uncommittedChanges: [], isGitRepo: false };
+        }
+        const [branch, log, status] = await Promise.all([
+            git.revparse(["--abbrev-ref", "HEAD"]),
+            git.log({ maxCount: 5 }),
+            git.status(),
+        ]);
+        const [latest, ...rest] = log.all;
+        return {
+            isGitRepo: true,
+            branch: branch.trim(),
+            lastCommit: latest
+                ? {
+                    hash: latest.hash.slice(0, 7),
+                    message: latest.message,
+                    author: latest.author_name,
+                    date: latest.date,
+                    timeAgo: timeAgo(latest.date),
+                }
+                : null,
+            recentCommits: rest.map((c) => ({
+                hash: c.hash.slice(0, 7),
+                message: c.message,
+                date: c.date,
+            })),
+            uncommittedChanges: [
+                ...status.modified,
+                ...status.created,
+                ...status.deleted,
+            ],
+        };
+    }
+    catch {
+        return { branch: "", lastCommit: null, recentCommits: [], uncommittedChanges: [], isGitRepo: false };
+    }
+}
+//# sourceMappingURL=gitContext.js.map

package/dist/scope/autoScope.d.ts

@@ -0,0 +1,2 @@
+export declare function autoDetectScope(projectRoot: string): Promise<string[]>;
+//# sourceMappingURL=autoScope.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"autoScope.d.ts","sourceRoot":"","sources":["../../src/scope/autoScope.ts"],"names":[],"mappings":"AAqIA,wBAAsB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAgD5E"}

package/dist/scope/autoScope.js

@@ -0,0 +1,226 @@
+"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.autoDetectScope = autoDetectScope;
+const simple_git_1 = __importDefault(require("simple-git"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const glob_1 = require("glob");
+// Files always included regardless of scope
+const ALWAYS_INCLUDE = [
+    "package.json",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "tsconfig.json",
+    "Cargo.toml",
+    "Cargo.lock",
+    "go.mod",
+    "go.sum",
+    "requirements.txt",
+    "pyproject.toml",
+    "README.md",
+    ".env.example",
+    "docker-compose.yml",
+    "Dockerfile",
+];
+function detectProjectType(projectRoot) {
+    if (fs.existsSync(path.join(projectRoot, "Cargo.toml")))
+        return "rust";
+    if (fs.existsSync(path.join(projectRoot, "package.json")))
+        return "node";
+    if (fs.existsSync(path.join(projectRoot, "pyproject.toml")) ||
+        fs.existsSync(path.join(projectRoot, "requirements.txt")))
+        return "python";
+    if (fs.existsSync(path.join(projectRoot, "go.mod")))
+        return "go";
+    return "unknown";
+}
+function parseRustWorkspaceMembers(projectRoot) {
+    const cargoPath = path.join(projectRoot, "Cargo.toml");
+    if (!fs.existsSync(cargoPath))
+        return [];
+    try {
+        const content = fs.readFileSync(cargoPath, "utf-8");
+        // Parse [workspace] members = [...] from Cargo.toml
+        const workspaceMatch = content.match(/\[workspace\][\s\S]*?members\s*=\s*\[([\s\S]*?)\]/);
+        if (!workspaceMatch)
+            return [];
+        const membersRaw = workspaceMatch[1];
+        return membersRaw
+            .split(",")
+            .map((m) => m.replace(/["'\s]/g, "").trim())
+            .filter((m) => m.length > 0 && !m.startsWith("#"))
+            .map((m) => m.replace(/\/\*$/, "").replace(/\*$/, "").trim()); // strip glob wildcards
+    }
+    catch {
+        return [];
+    }
+}
+async function getRustScope(projectRoot) {
+    const scope = new Set();
+    // Parse workspace members from Cargo.toml
+    const members = parseRustWorkspaceMembers(projectRoot);
+    if (members.length > 0) {
+        // It's a workspace — include src/ of each member
+        for (const member of members) {
+            const memberSrc = path.join(member, "src");
+            const fullMemberSrc = path.join(projectRoot, memberSrc);
+            if (fs.existsSync(fullMemberSrc)) {
+                scope.add(memberSrc);
+            }
+            // Also include member Cargo.toml
+            const memberCargo = path.join(member, "Cargo.toml");
+            if (fs.existsSync(path.join(projectRoot, memberCargo))) {
+                scope.add(memberCargo);
+            }
+        }
+    }
+    else {
+        // Single crate — just include src/
+        const srcPath = path.join(projectRoot, "src");
+        if (fs.existsSync(srcPath))
+            scope.add("src");
+    }
+    // Also catch any */src dirs not listed in workspace (safety net)
+    const allSrcDirs = await (0, glob_1.glob)("*/src", {
+        cwd: projectRoot,
+        ignore: ["node_modules/**", ".git/**", "target/**"],
+    });
+    for (const s of allSrcDirs)
+        scope.add(s);
+    return Array.from(scope);
+}
+async function getNodeScope(projectRoot) {
+    const scope = new Set();
+    const srcPath = path.join(projectRoot, "src");
+    if (fs.existsSync(srcPath))
+        scope.add("src");
+    // Check for monorepo patterns (packages/, apps/, libs/)
+    for (const dir of ["packages", "apps", "libs"]) {
+        const fullPath = path.join(projectRoot, dir);
+        if (fs.existsSync(fullPath))
+            scope.add(dir);
+    }
+    return Array.from(scope);
+}
+async function getPythonScope(projectRoot) {
+    const scope = new Set();
+    // Python projects typically have a src/ or a package dir matching project name
+    const srcPath = path.join(projectRoot, "src");
+    if (fs.existsSync(srcPath))
+        scope.add("src");
+    // Look for dirs with __init__.py
+    const initFiles = await (0, glob_1.glob)("*/__init__.py", {
+        cwd: projectRoot,
+        ignore: ["node_modules/**", ".git/**", "venv/**", ".venv/**"],
+    });
+    for (const f of initFiles)
+        scope.add(path.dirname(f));
+    return Array.from(scope);
+}
+async function getGoScope(projectRoot) {
+    const scope = new Set();
+    const internalPath = path.join(projectRoot, "internal");
+    const pkgPath = path.join(projectRoot, "pkg");
+    const cmdPath = path.join(projectRoot, "cmd");
+    if (fs.existsSync(internalPath))
+        scope.add("internal");
+    if (fs.existsSync(pkgPath))
+        scope.add("pkg");
+    if (fs.existsSync(cmdPath))
+        scope.add("cmd");
+    return Array.from(scope);
+}
+async function autoDetectScope(projectRoot) {
+    const git = (0, simple_git_1.default)(projectRoot);
+    const autoScope = new Set();
+    const projectType = detectProjectType(projectRoot);
+    // Step 1: Detect language-specific source dirs
+    let langScope = [];
+    switch (projectType) {
+        case "rust":
+            langScope = await getRustScope(projectRoot);
+            break;
+        case "node":
+            langScope = await getNodeScope(projectRoot);
+            break;
+        case "python":
+            langScope = await getPythonScope(projectRoot);
+            break;
+        case "go":
+            langScope = await getGoScope(projectRoot);
+            break;
+        default: {
+            const srcPath = path.join(projectRoot, "src");
+            if (fs.existsSync(srcPath))
+                langScope = ["src"];
+        }
+    }
+    for (const s of langScope)
+        autoScope.add(s);
+    // Step 2: Layer git activity on top — add dirs of recently modified files
+    try {
+        const log = await git.raw([
+            "log", "--since=7 days ago", "--name-only", "--pretty=format:", "--diff-filter=AM"
+        ]);
+        const recentFiles = log
+            .split("\n")
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0);
+        for (const file of recentFiles) {
+            const fullPath = path.join(projectRoot, file);
+            if (fs.existsSync(fullPath)) {
+                const dir = path.dirname(file);
+                if (dir !== ".")
+                    autoScope.add(dir);
+            }
+        }
+    }
+    catch {
+        // Not a git repo or no recent commits — lang scope is enough
+    }
+    // Step 3: Always include root-level config files
+    for (const file of ALWAYS_INCLUDE) {
+        const fullPath = path.join(projectRoot, file);
+        if (fs.existsSync(fullPath))
+            autoScope.add(file);
+    }
+    return Array.from(autoScope).filter((s) => s !== "." && s.length > 0);
+}
+//# sourceMappingURL=autoScope.js.map

package/dist/scope/config.d.ts

@@ -0,0 +1,10 @@
+export interface ScopeConfig {
+    active: string[];
+    watched: string[];
+    updatedAt: string;
+}
+export declare function getCliperDir(projectRoot: string): string;
+export declare function getScopeConfigPath(projectRoot: string): string;
+export declare function loadScopeConfig(projectRoot: string): ScopeConfig;
+export declare function saveScopeConfig(projectRoot: string, config: ScopeConfig): void;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/scope/config.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAQD,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,CAQhE;AAED,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,CAK9E"}