kennel 0.2.13 → 0.2.16

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

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

@@ -1,47 +0,0 @@
-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

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

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

@@ -1,17 +0,0 @@
-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

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

@@ -1,8 +0,0 @@
-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

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

@@ -1,5 +0,0 @@
-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

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

@@ -1,30 +0,0 @@
-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>;