kennel 0.1.9 → 0.2.1

package/node_modules/@raggle-ai/local/dist/core/skills.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultUserSkillRoots = void 0;
+exports.userSkillRoots = userSkillRoots;
+exports.userSkillProjects = userSkillProjects;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const project_source_settings_1 = require("./project-source-settings");
+/**
+ * Canonical user-level skill roots. These mirror the skill directories that
+ * per-repository `includeSkills` config recognises (`.agents/skills`,
+ * `.codex/skills`, `.claude/skills`, `.opencode/agent`) at the user level.
+ * Each entry is expanded against the home directory.
+ */
+exports.defaultUserSkillRoots = ["~/.agents/skills", "~/.claude/skills", "~/.codex/skills"];
+/** Resolve the configured user skill roots, or an empty list when the toggle is off. */
+function userSkillRoots(settings) {
+    if (!settings.includeUserSkills)
+        return [];
+    return exports.defaultUserSkillRoots.map((root) => (0, project_source_settings_1.expandHomePath)(root) ?? root).map((root) => node_path_1.default.resolve(root));
+}
+function isSkillDirectory(skillDir) {
+    try {
+        return (0, node_fs_1.statSync)(skillDir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function skillMarkerFile(skillDir) {
+    for (const marker of ["SKILL.md", "skill.md"]) {
+        const candidate = node_path_1.default.join(skillDir, marker);
+        if ((0, node_fs_1.existsSync)(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+/** Read the `name` and `description` values from a SKILL.md frontmatter block. */
+function skillFrontmatter(skillDir) {
+    const marker = skillMarkerFile(skillDir);
+    if (!marker)
+        return {};
+    let content;
+    try {
+        content = (0, node_fs_1.readFileSync)(marker, "utf8");
+    }
+    catch {
+        return {};
+    }
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content)?.[1];
+    if (!frontmatter)
+        return {};
+    const readKey = (key) => {
+        const value = new RegExp(`^${key}:(.*)$`, "m").exec(frontmatter)?.[1]?.trim();
+        if (!value)
+            return undefined;
+        const unquoted = value.replace(/^(["'])(.*)\1$/, "$2").trim();
+        return unquoted || undefined;
+    };
+    return { name: readKey("name"), description: readKey("description") };
+}
+/**
+ * Projects for every skill folder under the configured user skill roots.
+ *
+ * Only directories that contain a SKILL.md/skill.md marker become projects,
+ * mirroring the `hasDirectSkillMarker` convention used by project search.
+ * Returns an empty list when `includeUserSkills` is not enabled or no root
+ * exists. `roots` defaults to the resolved user skill roots and can be
+ * overridden for tests.
+ */
+function userSkillProjects(settings, roots = userSkillRoots(settings)) {
+    if (!settings.includeUserSkills)
+        return [];
+    const projects = [];
+    for (const repositoryRoot of roots) {
+        let entries;
+        try {
+            entries = (0, node_fs_1.readdirSync)(repositoryRoot, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        const skillNames = entries
+            .filter((entry) => !entry.name.startsWith(".") &&
+            !entry.name.startsWith("_") &&
+            (entry.isDirectory() || (entry.isSymbolicLink() && isSkillDirectory(node_path_1.default.join(repositoryRoot, entry.name)))))
+            .map((entry) => entry.name)
+            .sort();
+        for (const name of skillNames) {
+            const worktree = node_path_1.default.join(repositoryRoot, name);
+            if (!skillMarkerFile(worktree))
+                continue;
+            const frontmatter = skillFrontmatter(worktree);
+            projects.push({
+                id: `user-skill:${repositoryRoot}:${name}`,
+                worktree,
+                name: frontmatter.name ?? name,
+                ...(frontmatter.description ? { description: frontmatter.description } : {}),
+                sandboxCount: 0,
+                hasIcon: false,
+                isSessionOnly: false,
+                isFavorite: false,
+                relatedIds: [],
+                remoteUrl: `local:${repositoryRoot}`,
+                isCloned: true,
+                repositoryRoot,
+                relativePath: name,
+                listed: true,
+                projectType: "skill",
+            });
+        }
+    }
+    return projects;
+}

package/node_modules/@raggle-ai/local/dist/core/types.d.ts

@@ -0,0 +1,47 @@
+import type { DiscoveredRepository } from "../discovery/scanner";
+import type { LocalProject } from "./project-schema";
+export type { ImportedRepositorySubpath } from "./project-subpaths";
+export type { LocalProject, NormalizedRemoteProject, ProjectSearchDocument, ProjectSearchItemType, LinkedRepositoryConfig, RemoteProject, } from "./project-schema";
+export type LocalProjectLoadPhase = "repositories" | "resolved" | "subpaths";
+export type LocalProjectDelta = {
+    /** New or changed projects relative to LoadLocalProjectsOptions.previousItems. */
+    upserted: LocalProject[];
+    /** Stale worktrees, populated only by the authoritative final update. */
+    removedWorktrees: string[];
+};
+export type LocalProjectUpdate = {
+    /** The phase snapshot. Partial snapshots intentionally omit undiscovered subpaths. */
+    items: LocalProject[];
+    phase: LocalProjectLoadPhase;
+    /** True only when items is complete and safe to use as a replacement list. */
+    authoritative: boolean;
+    delta: LocalProjectDelta;
+};
+export type LoadLocalProjectsOptions = {
+    cloneDirectory: string;
+    ignoredSubpaths?: string[];
+    force?: boolean;
+    /** Receives the legacy phase items plus metadata describing completeness and changes. */
+    onUpdate?: (items: LocalProject[], update: LocalProjectUpdate) => void;
+    /** Last complete result, used as the baseline for progressive update deltas. */
+    previousItems?: readonly LocalProject[];
+    cloneIndexCachePath?: string;
+    cachedProjectsByWorktree?: Map<string, LocalProject>;
+    /** Repositories already discovered in cloneDirectory, so indexing can skip its own scan. */
+    scannedRepositories?: DiscoveredRepository[];
+    /**
+     * Extra marker file names (like the built-in kennel.json). A directory that
+     * contains one becomes an all-folder subpath root, so its child folders are
+     * included automatically. Root-level discovery of these markers runs for any
+     * repository whose root has a raggle.json, even without collapseSubpaths.
+     */
+    subpathMarkerFiles?: string[];
+    /**
+     * Repo config file names checked at repository roots and subpath folders.
+     * Checked in order, first existing file wins; custom names take priority
+     * over the defaults raggle.json and index.json (which always remain as
+     * fallbacks).
+     */
+    projectConfigFiles?: string[];
+};
+export type { ProjectActionConfig } from "./project-actions";

package/node_modules/@raggle-ai/local/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@raggle-ai/local/dist/core/user-projects.d.ts

@@ -0,0 +1,17 @@
+import type { LocalProject } from "./types";
+export declare const userProjectCacheMaxAgeMs = 60000;
+export type UserProjectScope = "all" | "baseRepositoryManifestChildren";
+export type UserProjectLoadOptions = {
+    preferBaseRepository?: boolean;
+    scope?: UserProjectScope;
+};
+export type UserProjectCacheSnapshot = {
+    projects: LocalProject[];
+    generatedAt: number;
+    ageMs: number;
+    status: "fresh" | "stale";
+};
+export declare function loadUserProjects(options?: UserProjectLoadOptions): Promise<LocalProject[]>;
+export declare function loadCachedUserProjects(options?: UserProjectLoadOptions): LocalProject[] | undefined;
+export declare function readCachedUserProjectSnapshot(options?: UserProjectLoadOptions): UserProjectCacheSnapshot | undefined;
+export declare function writeUserProjectCache(projects: LocalProject[], options?: UserProjectLoadOptions): void;

package/node_modules/@raggle-ai/local/dist/core/user-projects.js

@@ -0,0 +1,317 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userProjectCacheMaxAgeMs = void 0;
+exports.loadUserProjects = loadUserProjects;
+exports.loadCachedUserProjects = loadCachedUserProjects;
+exports.readCachedUserProjectSnapshot = readCachedUserProjectSnapshot;
+exports.writeUserProjectCache = writeUserProjectCache;
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const user_settings_1 = require("../adapters/user-settings");
+const project_source_1 = require("../adapters/project-source");
+const turso_project_source_1 = require("../adapters/turso-project-source");
+const git_repository_1 = require("../adapters/git-repository");
+const project_display_name_1 = require("../adapters/project-display-name");
+const native_bridge_1 = require("../native-bridge");
+const catalog_project_1 = require("./catalog-project");
+const project_add_1 = require("./project-add");
+const project_emoji_1 = require("./project-emoji");
+const logging_1 = require("./logging");
+const search_1 = require("./search");
+const skills_1 = require("./skills");
+const native_bridge_2 = require("../native-bridge");
+const cliIconCacheDir = node_path_1.default.join(process.env.XDG_CACHE_HOME ?? node_path_1.default.join(node_os_1.default.homedir(), ".cache"), "raggle", "project-icons");
+const userProjectCatalogsDir = node_path_1.default.join(process.env.XDG_CACHE_HOME ?? node_path_1.default.join(node_os_1.default.homedir(), ".cache"), "raggle", "user-project-catalogs");
+// Rebuild catalogs that included implicit manifest-presence search priorities.
+const userProjectCacheSchemaVersion = 2;
+exports.userProjectCacheMaxAgeMs = 60_000;
+let cacheWriteSequence = 0;
+const inFlightUserProjectCatalogs = new Map();
+function userProjectContext(options) {
+    const cwdConfiguredRoot = (0, node_fs_1.statSync)(process.cwd(), { throwIfNoEntry: false })?.isDirectory() && (0, native_bridge_2.hasProjectConfig)(process.cwd())
+        ? process.cwd()
+        : undefined;
+    const configuredRoots = cwdConfiguredRoot ? [cwdConfiguredRoot] : [];
+    const settings = (0, user_settings_1.readRaggleUserSettings)();
+    const cwdRelativeToBase = settings.baseRepository ? node_path_1.default.relative(settings.baseRepository, process.cwd()) : undefined;
+    const cwdIsInBaseRepository = cwdRelativeToBase !== undefined &&
+        (cwdRelativeToBase === "" || (!cwdRelativeToBase.startsWith("..") && !node_path_1.default.isAbsolute(cwdRelativeToBase)));
+    return {
+        settings,
+        configuredRoots,
+        useBaseRepository: options.preferBaseRepository && cwdIsInBaseRepository,
+        scope: options.scope ?? "all",
+    };
+}
+function selectUserProjects(projects, context) {
+    if (context.scope === "all")
+        return projects;
+    const baseRepository = context.settings.baseRepository;
+    if (!baseRepository)
+        return [];
+    return projects.filter((project) => {
+        const relativePath = node_path_1.default.relative(baseRepository, project.worktree);
+        if (!relativePath || relativePath.startsWith("..") || node_path_1.default.isAbsolute(relativePath))
+            return false;
+        return (0, node_fs_1.statSync)(node_path_1.default.join(project.worktree, "raggle.json"), { throwIfNoEntry: false })?.isFile() === true;
+    });
+}
+function userProjectCacheKey(context) {
+    const { settings } = context;
+    return (0, node_crypto_1.createHash)("sha256")
+        .update(JSON.stringify({
+        cloneDirectories: context.useBaseRepository ? [] : settings.cloneDirectories,
+        projectDirectories: settings.projectDirectories,
+        includeUserSkills: settings.includeUserSkills,
+        baseRepository: settings.baseRepository,
+        configuredRoots: context.configuredRoots,
+        useBaseRepository: Boolean(context.useBaseRepository),
+        repositoryLocations: settings.repositoryLocations,
+        localRepositoryLinks: settings.localRepositoryLinks,
+        projectStoreUrl: (0, project_source_1.projectSourceOptionsForCli)().tursoDatabaseUrl ?? null,
+    }))
+        .digest("hex");
+}
+function isCachedProject(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const project = value;
+    return (typeof project.id === "string" &&
+        typeof project.worktree === "string" &&
+        typeof project.remoteUrl === "string" &&
+        typeof project.repositoryRoot === "string");
+}
+function gitValue(folder, args) {
+    try {
+        return (0, node_child_process_1.execFileSync)("git", ["-C", folder, ...args], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function localProjectFromWorktree(worktree, owner, relatedIds = []) {
+    const repositoryRoot = gitValue(worktree, ["rev-parse", "--show-toplevel"]) ?? worktree;
+    const remoteUrl = gitValue(repositoryRoot, ["remote", "get-url", "origin"]) ?? owner;
+    const relativePath = node_path_1.default.relative(repositoryRoot, worktree);
+    return {
+        id: `local-folder:${worktree}`,
+        worktree,
+        name: (0, project_add_1.deriveProjectName)(remoteUrl) || node_path_1.default.basename(worktree),
+        sandboxCount: 0,
+        hasIcon: false,
+        isSessionOnly: false,
+        isFavorite: false,
+        relatedIds,
+        remoteUrl,
+        isCloned: true,
+        repositoryRoot,
+        ...(relativePath && !relativePath.startsWith("..") && !node_path_1.default.isAbsolute(relativePath)
+            ? { relativePath: relativePath.split(node_path_1.default.sep).join("/") }
+            : {}),
+        listed: true,
+    };
+}
+function localLinkedProjects(settings, existingProjects) {
+    const existingWorktrees = new Set(existingProjects.map((project) => node_path_1.default.resolve(project.worktree)));
+    const projects = [];
+    for (const [owner, targets] of Object.entries(settings.localRepositoryLinks)) {
+        for (const target of targets) {
+            const worktree = node_path_1.default.resolve(target);
+            if (existingWorktrees.has(worktree) || !(0, node_fs_1.statSync)(worktree, { throwIfNoEntry: false })?.isDirectory())
+                continue;
+            projects.push(localProjectFromWorktree(worktree, owner, [owner]));
+            existingWorktrees.add(worktree);
+        }
+    }
+    return projects;
+}
+function localRepositoryLocationProjects(settings, existingProjects) {
+    const existingWorktrees = new Set(existingProjects.map((project) => node_path_1.default.resolve(project.worktree)));
+    const projects = [];
+    for (const [owner, location] of Object.entries(settings.repositoryLocations)) {
+        const worktree = node_path_1.default.resolve(location.preferredWorktree);
+        if (existingWorktrees.has(worktree) || !(0, node_fs_1.statSync)(worktree, { throwIfNoEntry: false })?.isDirectory())
+            continue;
+        projects.push(localProjectFromWorktree(worktree, owner));
+        existingWorktrees.add(worktree);
+    }
+    return projects;
+}
+// Cache-first store discovery; a failed refresh must not hide local projects.
+async function loadStoreRepositories(cloneDirectory) {
+    const source = (0, project_source_1.projectSourceOptionsForCli)();
+    if (!source.tursoDatabaseUrl)
+        return [];
+    const settings = { ...source, cloneDirectory, cachePath: source.tursoCachePath };
+    const cached = (0, turso_project_source_1.readCachedTursoProjectRows)(settings);
+    let rows = cached?.rows ?? [];
+    if (!cached || Date.now() - cached.generatedAt > 15 * 60_000) {
+        try {
+            rows = await (0, turso_project_source_1.readTursoProjectRows)(settings);
+        }
+        catch {
+            (0, logging_1.logEvent)("projects", "Project store refresh failed; using cached rows and local discovery.");
+        }
+    }
+    return (0, project_source_1.loadProjectSourceRows)(rows);
+}
+function storeOnlyProjects(repositories, existingProjects, cloneDirectory, repositoryLocations = {}) {
+    const existingKeys = new Set([
+        ...existingProjects.map((project) => (0, git_repository_1.repositoryLocationKey)(project.remoteUrl)?.toLowerCase()),
+        ...Object.keys(repositoryLocations).map((key) => (0, git_repository_1.repositoryLocationKey)(key)?.toLowerCase()),
+    ].filter((key) => Boolean(key)));
+    return repositories.flatMap((repository) => {
+        const key = (0, git_repository_1.repositoryLocationKey)(repository.remoteUrl)?.toLowerCase();
+        if (key && existingKeys.has(key))
+            return [];
+        const worktree = cloneDirectory ? (0, project_add_1.repositoryRootPath)(repository, cloneDirectory) : repository.remoteUrl;
+        return [
+            {
+                id: `remote:${key ?? repository.remoteUrl}`,
+                worktree,
+                name: repository.name,
+                description: repository.description,
+                tags: repository.tags,
+                plugins: repository.plugins,
+                sandboxCount: 0,
+                hasIcon: false,
+                isSessionOnly: false,
+                isFavorite: false,
+                relatedIds: [],
+                remoteUrl: repository.remoteUrl,
+                isCloned: false,
+                repositoryRoot: worktree,
+                listed: true,
+                allSubpath: repository.allSubpath,
+                collapseSubpaths: repository.collapseSubpaths,
+                allTopLevelFolders: repository.allTopLevelFolders,
+                folderDepth: repository.folderDepth,
+                removePathFromName: repository.removePathFromName,
+                hasCustomName: repository.hasCustomName,
+                searchPriority: repository.searchPriority,
+                relatedRepositories: repository.linkedRepositories,
+                relatedOrganisations: repository.linkedOrganisations.map((item) => item.organisation),
+            },
+        ];
+    });
+}
+async function buildUserProjectCatalog(context, cacheKey) {
+    const { settings } = context;
+    const baseRepository = settings.baseRepository;
+    const cloneDirectory = settings.cloneDirectories[0];
+    const repositories = !context.useBaseRepository ? await loadStoreRepositories(cloneDirectory) : [];
+    const catalogProjects = await (0, native_bridge_2.buildProjectCatalog)({
+        cloneSources: context.useBaseRepository
+            ? []
+            : settings.cloneDirectories.map((directory) => ({ cloneDirectory: directory, repositories })),
+        projectRoots: [
+            ...settings.projectDirectories,
+            ...(baseRepository ? [baseRepository] : []),
+            ...context.configuredRoots,
+        ],
+        repositoryLocations: settings.repositoryLocations,
+        localRepositoryLinks: settings.localRepositoryLinks,
+        iconCacheDir: cliIconCacheDir,
+        schemaScanRoots: [...new Set([...settings.projectDirectories, ...(baseRepository ? [baseRepository] : [])])],
+    });
+    const locatedRepositoryKeys = new Set(Object.keys(settings.repositoryLocations)
+        .map((key) => (0, git_repository_1.repositoryLocationKey)(key)?.toLowerCase())
+        .filter((key) => Boolean(key)));
+    const catalogLocalProjects = catalogProjects.map(catalog_project_1.catalogProjectToLocalProject).filter((project) => {
+        if (project.isCloned !== false)
+            return true;
+        const key = (0, git_repository_1.repositoryLocationKey)(project.remoteUrl)?.toLowerCase();
+        return !key || !locatedRepositoryKeys.has(key);
+    });
+    const locatedProjects = localRepositoryLocationProjects(settings, catalogLocalProjects);
+    const knownLocalProjects = [...catalogLocalProjects, ...locatedProjects];
+    const allProjects = (0, search_1.withBaseRepositoryProjects)([
+        ...knownLocalProjects,
+        ...storeOnlyProjects(repositories, knownLocalProjects, cloneDirectory, settings.repositoryLocations),
+        ...localLinkedProjects(settings, knownLocalProjects),
+        ...(0, skills_1.userSkillProjects)(settings),
+    ], baseRepository);
+    (0, logging_1.logEvent)("projects", `loaded ${allProjects.length} from Rust catalogue`);
+    try {
+        writeUserProjectCacheRecord(allProjects, cacheKey);
+    }
+    catch (error) {
+        (0, logging_1.logEvent)("projects", `could not write user project cache: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return allProjects;
+}
+async function loadUserProjects(options = {}) {
+    const context = userProjectContext(options);
+    const cacheKey = userProjectCacheKey(context);
+    let catalogPromise = inFlightUserProjectCatalogs.get(cacheKey);
+    if (!catalogPromise) {
+        catalogPromise = buildUserProjectCatalog(context, cacheKey);
+        inFlightUserProjectCatalogs.set(cacheKey, catalogPromise);
+    }
+    let allProjects;
+    try {
+        allProjects = await catalogPromise;
+    }
+    finally {
+        if (inFlightUserProjectCatalogs.get(cacheKey) === catalogPromise) {
+            inFlightUserProjectCatalogs.delete(cacheKey);
+        }
+    }
+    return (0, project_display_name_1.applyProjectDisplayNames)((0, native_bridge_1.applyProjectFavorites)(selectUserProjects(allProjects, context), context.settings.favoriteProjects), context.settings.projectDisplayNames).map(project_emoji_1.withProjectEmoji);
+}
+function loadCachedUserProjects(options = {}) {
+    const snapshot = readCachedUserProjectSnapshot(options);
+    return snapshot?.projects;
+}
+function readCachedUserProjectSnapshot(options = {}) {
+    const context = userProjectContext(options);
+    const cacheKey = userProjectCacheKey(context);
+    const cacheFile = node_path_1.default.join(userProjectCatalogsDir, `${cacheKey}.json`);
+    try {
+        const cached = JSON.parse((0, node_fs_1.readFileSync)(cacheFile, "utf8"));
+        if (cached.schemaVersion !== userProjectCacheSchemaVersion ||
+            cached.cacheKey !== cacheKey ||
+            !Array.isArray(cached.projects) ||
+            !cached.projects.every(isCachedProject) ||
+            typeof cached.generatedAt !== "number") {
+            return undefined;
+        }
+        const projects = (0, project_display_name_1.applyProjectDisplayNames)((0, native_bridge_1.applyProjectFavorites)(selectUserProjects(cached.projects, context), context.settings.favoriteProjects), context.settings.projectDisplayNames).map(project_emoji_1.withProjectEmoji);
+        const ageMs = Math.max(0, Date.now() - cached.generatedAt);
+        return {
+            projects,
+            generatedAt: cached.generatedAt,
+            ageMs,
+            status: ageMs <= exports.userProjectCacheMaxAgeMs ? "fresh" : "stale",
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeUserProjectCache(projects, options = {}) {
+    const context = userProjectContext(options);
+    const cacheKey = userProjectCacheKey(context);
+    writeUserProjectCacheRecord(projects, cacheKey);
+}
+function writeUserProjectCacheRecord(projects, cacheKey) {
+    const cacheFile = node_path_1.default.join(userProjectCatalogsDir, `${cacheKey}.json`);
+    const temporaryPath = `${cacheFile}.tmp-${process.pid}-${++cacheWriteSequence}`;
+    (0, node_fs_1.mkdirSync)(userProjectCatalogsDir, { recursive: true });
+    (0, node_fs_1.writeFileSync)(temporaryPath, JSON.stringify({
+        schemaVersion: userProjectCacheSchemaVersion,
+        cacheKey,
+        generatedAt: Date.now(),
+        projects,
+    }), "utf8");
+    (0, node_fs_1.renameSync)(temporaryPath, cacheFile);
+}

package/node_modules/@raggle-ai/local/dist/discovery/markdown-files.d.ts

@@ -0,0 +1,8 @@
+export type MarkdownFileCandidate = {
+    path: string;
+    relativePath: string;
+    size: number;
+    modifiedAtMs: number;
+};
+/** Runs the bounded native candidate scan without applying product ordering or Git rules. */
+export declare function scanMarkdownFileCandidates(folder: string): Promise<MarkdownFileCandidate[]>;

package/node_modules/@raggle-ai/local/dist/discovery/markdown-files.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanMarkdownFileCandidates = scanMarkdownFileCandidates;
+const node_path_1 = __importDefault(require("node:path"));
+const native_1 = require("../native");
+const maxMarkdownFiles = 100_000;
+const markdownScanTimeoutMs = 30_000;
+/** Runs the bounded native candidate scan without applying product ordering or Git rules. */
+async function scanMarkdownFileCandidates(folder) {
+    const result = await (0, native_1.loadNativeModule)().scanMarkdownFiles(node_path_1.default.resolve(folder), {
+        maxFiles: maxMarkdownFiles,
+        timeoutMs: markdownScanTimeoutMs,
+    });
+    if (result.timedOut) {
+        throw new Error(`Markdown file scan timed out after ${result.timeoutMs} ms: ${folder}`);
+    }
+    if (result.truncated) {
+        throw new Error(`Markdown file scan exceeded ${result.maxFiles} files: ${folder}`);
+    }
+    return result.files.map((file) => ({
+        ...file,
+        path: node_path_1.default.resolve(file.path),
+    }));
+}

package/node_modules/@raggle-ai/local/dist/discovery/project-folders.d.ts

@@ -0,0 +1,5 @@
+export declare function readTopLevelProjectFolders(rootPath: string): string[];
+export declare function discoverProjectFolders(rootPath: string, options?: {
+    maxFolders?: number;
+    maxDepth?: number;
+}): Promise<string[]>;

package/node_modules/@raggle-ai/local/dist/discovery/project-folders.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTopLevelProjectFolders = readTopLevelProjectFolders;
+exports.discoverProjectFolders = discoverProjectFolders;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const ignoredFolderNames = new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    ".next",
+    ".turbo",
+    ".vercel",
+    "target",
+    "vendor",
+]);
+function readTopLevelProjectFolders(rootPath) {
+    try {
+        return (0, node_fs_1.readdirSync)(rootPath, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+            .map((entry) => entry.name)
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}
+async function discoverProjectFolders(rootPath, options = {}) {
+    const maxFolders = options.maxFolders ?? 500;
+    const maxDepth = options.maxDepth ?? 3;
+    const folders = new Set();
+    const queue = [{ directory: rootPath, depth: 0 }];
+    while (queue.length && folders.size < maxFolders) {
+        const current = queue.shift();
+        if (!current || current.depth >= maxDepth)
+            continue;
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(current.directory, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith(".") || ignoredFolderNames.has(entry.name))
+                continue;
+            const nextPath = node_path_1.default.join(current.directory, entry.name);
+            folders.add(node_path_1.default.relative(rootPath, nextPath).split(node_path_1.default.sep).join("/"));
+            if (folders.size >= maxFolders)
+                break;
+            queue.push({ directory: nextPath, depth: current.depth + 1 });
+        }
+    }
+    return [...folders].sort((left, right) => left.localeCompare(right));
+}

package/node_modules/@raggle-ai/local/dist/discovery/scanner.d.ts

@@ -0,0 +1,30 @@
+export type DiscoveredRepository = {
+    worktree: string;
+    remoteUrl: string;
+    currentBranch?: string;
+};
+export type ScanCloneDirectoryOptions = {
+    maxDepth?: number;
+    maxRepos?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    onProgress?: (repository: DiscoveredRepository, count: number) => void;
+};
+export type ScanCloneDirectoryResult = {
+    repositories: DiscoveredRepository[];
+    warnings: string[];
+    truncated: boolean;
+    timedOut: boolean;
+    stopped: boolean;
+    durationMs: number;
+    maxDepth: number;
+    maxRepos: number;
+    timeoutMs: number;
+};
+/** Identifies a Git repository rooted at exactly the supplied directory. */
+export declare function discoverRepository(directory: string): DiscoveredRepository | undefined;
+/**
+ * Discovers repositories without blocking the JavaScript event loop. Traversal
+ * runs in napi-rs' async worker pool and is bounded by depth, count, and time.
+ */
+export declare function scanCloneDirectoryRepositories(cloneDirectory: string, options?: ScanCloneDirectoryOptions): Promise<ScanCloneDirectoryResult>;