harborloop 0.3.0 → 0.4.1

package/dist/providers/cursor.js

@@ -1,344 +0,0 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { ensureConfigDir, readIfExists, updateFileLocked } from '../lock.js';
-import { isUnrunnableCommandEntry } from './hook-entry.js';
-import { HOOK_CAPTURE_BASENAME, HOOK_CONTEXT_BASENAME, HOOK_REPORT_BASENAME, HOOK_COMPACT_BASENAME, HOOK_TOOLCONTEXT_BASENAME, LEGACY_MCP_KEYS, MCP_KEY, } from './claude.js';
-const HOOK_CONTEXT_TIMEOUT_S = 8;
-const HOOK_REPORT_TIMEOUT_S = 5;
-const HOOK_CAPTURE_TIMEOUT_S = 10;
-const HOOK_TOOLCONTEXT_TIMEOUT_S = 5;
-const HOOK_COMPACT_TIMEOUT_S = 2;
-const EVENT_SESSION_START = 'sessionStart';
-const EVENT_SESSION_END = 'sessionEnd';
-const EVENT_STOP = 'stop';
-const EVENT_POST_TOOL_USE = 'postToolUse';
-const EVENT_PRE_TOOL_USE = 'preToolUse';
-const EVENT_PRE_COMPACT = 'preCompact';
-export const MANAGED_HOOK_EVENTS = [
-    EVENT_SESSION_START,
-    EVENT_SESSION_END,
-    EVENT_STOP,
-    EVENT_POST_TOOL_USE,
-    EVENT_PRE_TOOL_USE,
-    EVENT_PRE_COMPACT,
-];
-const CURSOR_HOOK_EVENTS = MANAGED_HOOK_EVENTS;
-const TOOLCONTEXT_EDIT_MATCHER = 'Write';
-const TOOLCONTEXT_SHELL_MATCHER = 'Shell';
-const HOOKS_CONFIG_VERSION = 1;
-export function resolveCursorPaths(home = homedir()) {
-    const cursorDir = join(home, '.cursor');
-    return {
-        cursorDir,
-        mcpJsonPath: join(cursorDir, 'mcp.json'),
-        hooksJsonPath: join(cursorDir, 'hooks.json'),
-    };
-}
-export function stripJsonComments(raw) {
-    let out = '';
-    let hadComments = false;
-    let i = 0;
-    while (i < raw.length) {
-        const ch = raw[i];
-        if (ch === '"') {
-            out += ch;
-            i += 1;
-            while (i < raw.length) {
-                const c = raw[i];
-                out += c;
-                i += 1;
-                if (c === '\\') {
-                    if (i < raw.length) {
-                        out += raw[i];
-                        i += 1;
-                    }
-                    continue;
-                }
-                if (c === '"')
-                    break;
-            }
-            continue;
-        }
-        if (ch === '/' && raw[i + 1] === '/') {
-            hadComments = true;
-            while (i < raw.length && raw[i] !== '\n')
-                i += 1;
-            continue;
-        }
-        if (ch === '/' && raw[i + 1] === '*') {
-            hadComments = true;
-            i += 2;
-            while (i < raw.length && !(raw[i] === '*' && raw[i + 1] === '/'))
-                i += 1;
-            i += 2;
-            continue;
-        }
-        out += ch;
-        i += 1;
-    }
-    return { text: out, hadComments };
-}
-function assertRoundTrips(hadComments, file) {
-    if (!hadComments)
-        return;
-    throw new Error(`${file} contains comments, which this writer would delete. ` +
-        `Remove them (or move them into a "_comment" string field) and re-run.`);
-}
-function parseRoot(existing, allowEmpty, file) {
-    if (existing.trim().length === 0) {
-        if (allowEmpty)
-            return { root: {}, hadComments: false };
-        throw new Error(`${file} is empty`);
-    }
-    const { text, hadComments } = stripJsonComments(existing);
-    let root;
-    try {
-        root = JSON.parse(text);
-    }
-    catch (err) {
-        throw new Error(`Failed to parse ${file}: ${err.message}`);
-    }
-    if (root === null || typeof root !== 'object' || Array.isArray(root)) {
-        throw new Error(`${file} root is not an object`);
-    }
-    return { root: root, hadComments };
-}
-function parseQuietly(existing) {
-    if (existing.trim() === '')
-        return null;
-    try {
-        const root = JSON.parse(stripJsonComments(existing).text);
-        if (root === null || typeof root !== 'object' || Array.isArray(root))
-            return null;
-        return root;
-    }
-    catch {
-        return null;
-    }
-}
-const serialise = (root) => `${JSON.stringify(root, null, 2)}\n`;
-export function buildMcpServerEntry(mcpUrl, token) {
-    return { url: mcpUrl, headers: { Authorization: `Bearer ${token}` } };
-}
-function deleteAllOurKeys(servers) {
-    delete servers[MCP_KEY];
-    for (const legacy of LEGACY_MCP_KEYS)
-        delete servers[legacy];
-}
-export function mergeMcpServer(existing, mcpUrl, token) {
-    const { root, hadComments } = parseRoot(existing, true, 'mcp.json');
-    assertRoundTrips(hadComments, 'mcp.json');
-    let servers = root.mcpServers;
-    if (servers === undefined) {
-        servers = {};
-        root.mcpServers = servers;
-    }
-    if (servers === null || typeof servers !== 'object' || Array.isArray(servers)) {
-        throw new Error('mcp.json `mcpServers` is not an object');
-    }
-    deleteAllOurKeys(servers);
-    servers[MCP_KEY] = buildMcpServerEntry(mcpUrl, token);
-    return serialise(root);
-}
-export function removeMcpServer(existing) {
-    if (existing.trim() === '')
-        return existing;
-    const { root, hadComments } = parseRoot(existing, false, 'mcp.json');
-    assertRoundTrips(hadComments, 'mcp.json');
-    const servers = root.mcpServers;
-    if (servers !== null && typeof servers === 'object' && !Array.isArray(servers)) {
-        deleteAllOurKeys(servers);
-    }
-    return serialise(root);
-}
-export function hasMcpServer(existing) {
-    return readInstalledToken(existing) !== null;
-}
-export function readInstalledToken(existing) {
-    const root = parseQuietly(existing);
-    const servers = root?.mcpServers;
-    if (servers === null || servers === undefined || typeof servers !== 'object')
-        return null;
-    const entry = servers[MCP_KEY];
-    if (entry === null || entry === undefined || typeof entry !== 'object')
-        return null;
-    const headers = entry.headers;
-    if (headers === null || headers === undefined || typeof headers !== 'object')
-        return null;
-    const auth = headers.Authorization;
-    if (typeof auth !== 'string' || auth.trim() === '')
-        return null;
-    return auth.startsWith('Bearer ') ? auth.slice('Bearer '.length) : auth;
-}
-export function readInstalledMcpUrl(existing) {
-    const root = parseQuietly(existing);
-    const servers = root?.mcpServers;
-    const entry = servers?.[MCP_KEY];
-    return typeof entry?.url === 'string' ? entry.url : null;
-}
-const HOOK_BASENAMES = [
-    HOOK_CONTEXT_BASENAME,
-    HOOK_REPORT_BASENAME,
-    HOOK_CAPTURE_BASENAME,
-    HOOK_TOOLCONTEXT_BASENAME,
-    HOOK_COMPACT_BASENAME,
-];
-export function shellQuote(command) {
-    return /^[A-Za-z0-9_@%+=:,./-]+$/.test(command)
-        ? command
-        : `'${command.replace(/'/g, `'\\''`)}'`;
-}
-export function isOurHookCommand(command) {
-    if (typeof command !== 'string')
-        return false;
-    const bare = command.trim().replace(/^['"]|['"]$/g, '');
-    const base = bare.split(/[\\/]/).pop();
-    return base !== undefined && HOOK_BASENAMES.includes(base);
-}
-function stripOurHooks(event) {
-    if (!Array.isArray(event))
-        return [];
-    const kept = [];
-    for (const entry of event) {
-        if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) {
-            kept.push(entry);
-            continue;
-        }
-        if (isUnrunnableCommandEntry(entry))
-            continue;
-        if (isOurHookCommand(entry.command))
-            continue;
-        kept.push(entry);
-    }
-    return kept;
-}
-const hookEntry = (command, timeout, matcher) => ({
-    ...(matcher === undefined ? {} : { matcher }),
-    command: shellQuote(command),
-    timeout,
-});
-export function mergeHooks(existing, paths) {
-    const { root, hadComments } = parseRoot(existing, true, 'hooks.json');
-    assertRoundTrips(hadComments, 'hooks.json');
-    if (typeof root.version !== 'number' || !Number.isInteger(root.version) || root.version < 1) {
-        root.version = HOOKS_CONFIG_VERSION;
-    }
-    let hooks = root.hooks;
-    if (hooks === undefined) {
-        hooks = {};
-        root.hooks = hooks;
-    }
-    if (hooks === null || typeof hooks !== 'object' || Array.isArray(hooks)) {
-        throw new Error('hooks.json `hooks` is not an object');
-    }
-    const h = hooks;
-    h[EVENT_SESSION_START] = [
-        ...stripOurHooks(h[EVENT_SESSION_START]),
-        hookEntry(paths.contextHookPath, HOOK_CONTEXT_TIMEOUT_S),
-    ];
-    h[EVENT_SESSION_END] = [
-        ...stripOurHooks(h[EVENT_SESSION_END]),
-        hookEntry(paths.reportHookPath, HOOK_REPORT_TIMEOUT_S),
-    ];
-    h[EVENT_STOP] = [
-        ...stripOurHooks(h[EVENT_STOP]),
-        hookEntry(paths.captureHookPath, HOOK_CAPTURE_TIMEOUT_S),
-    ];
-    h[EVENT_POST_TOOL_USE] = [
-        ...stripOurHooks(h[EVENT_POST_TOOL_USE]),
-        hookEntry(paths.toolContextHookPath, HOOK_TOOLCONTEXT_TIMEOUT_S, TOOLCONTEXT_EDIT_MATCHER),
-    ];
-    h[EVENT_PRE_TOOL_USE] = [
-        ...stripOurHooks(h[EVENT_PRE_TOOL_USE]),
-        hookEntry(paths.toolContextHookPath, HOOK_TOOLCONTEXT_TIMEOUT_S, TOOLCONTEXT_SHELL_MATCHER),
-    ];
-    h[EVENT_PRE_COMPACT] = [
-        ...stripOurHooks(h[EVENT_PRE_COMPACT]),
-        hookEntry(paths.compactHookPath, HOOK_COMPACT_TIMEOUT_S),
-    ];
-    return serialise(root);
-}
-export function removeHooks(existing) {
-    if (existing.trim() === '')
-        return existing;
-    const { root, hadComments } = parseRoot(existing, false, 'hooks.json');
-    assertRoundTrips(hadComments, 'hooks.json');
-    const hooks = root.hooks;
-    if (hooks !== null && typeof hooks === 'object' && !Array.isArray(hooks)) {
-        const h = hooks;
-        for (const event of CURSOR_HOOK_EVENTS) {
-            if (!(event in h))
-                continue;
-            const stripped = stripOurHooks(h[event]);
-            if (stripped.length === 0)
-                delete h[event];
-            else
-                h[event] = stripped;
-        }
-        if (Object.keys(h).length === 0) {
-            delete root.hooks;
-            delete root.version;
-        }
-    }
-    return serialise(root);
-}
-export function readInstalledHooks(existing) {
-    const commands = [];
-    const events = [];
-    const empty = { installed: false, commands, events };
-    const root = parseQuietly(existing);
-    if (root === null)
-        return empty;
-    const hooks = root.hooks;
-    if (hooks === null || typeof hooks !== 'object' || Array.isArray(hooks))
-        return empty;
-    for (const event of CURSOR_HOOK_EVENTS) {
-        const entries = hooks[event];
-        if (!Array.isArray(entries))
-            continue;
-        const before = commands.length;
-        for (const entry of entries) {
-            if (entry === null || typeof entry !== 'object')
-                continue;
-            const command = entry.command;
-            if (isOurHookCommand(command)) {
-                commands.push(String(command).trim().replace(/^['"]|['"]$/g, ''));
-            }
-        }
-        if (commands.length > before)
-            events.push(event);
-    }
-    return { installed: commands.length > 0, commands, events };
-}
-export function hasHooks(existing) {
-    return readInstalledHooks(existing).installed;
-}
-const ensureCursorDir = ensureConfigDir;
-export async function readCursorMcpJson(home) {
-    return readIfExists(resolveCursorPaths(home).mcpJsonPath);
-}
-export async function readCursorHooksJson(home) {
-    return readIfExists(resolveCursorPaths(home).hooksJsonPath);
-}
-export async function installMcpServer(opts) {
-    const paths = resolveCursorPaths(opts.home);
-    await ensureCursorDir(paths.cursorDir);
-    await updateFileLocked(paths.mcpJsonPath, (existing) => mergeMcpServer(existing, opts.mcpUrl, opts.token));
-    return paths.mcpJsonPath;
-}
-export async function uninstallMcpServer(home) {
-    const paths = resolveCursorPaths(home);
-    await updateFileLocked(paths.mcpJsonPath, (existing) => removeMcpServer(existing));
-    return paths.mcpJsonPath;
-}
-export async function installHooks(paths, home) {
-    const cursor = resolveCursorPaths(home);
-    await ensureCursorDir(cursor.cursorDir);
-    await updateFileLocked(cursor.hooksJsonPath, (existing) => mergeHooks(existing, paths));
-    return cursor.hooksJsonPath;
-}
-export async function uninstallHooks(home) {
-    const paths = resolveCursorPaths(home);
-    await updateFileLocked(paths.hooksJsonPath, (existing) => removeHooks(existing));
-    return paths.hooksJsonPath;
-}

package/dist/providers/detect.d.ts

@@ -1,16 +0,0 @@
-export type AgentId = 'claude' | 'codex' | 'cursor';
-export declare const MINT_PROVIDER: Record<AgentId, string>;
-export interface AgentPresence {
-    readonly claude: boolean;
-    readonly codex: boolean;
-    readonly cursor: boolean;
-}
-export declare function detectAgents(home?: string): Promise<AgentPresence>;
-export interface AgentSelection {
-    readonly agents: readonly AgentId[];
-    readonly fellBack: boolean;
-}
-export declare function selectAgents(present: AgentPresence, flags?: {
-    readonly codex?: boolean;
-    readonly cursor?: boolean;
-}): AgentSelection;

package/dist/providers/detect.js

@@ -1,70 +0,0 @@
-import { constants } from 'node:fs';
-import { access, stat } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { delimiter, join } from 'node:path';
-import { resolveCodexPaths } from './codex.js';
-import { resolveCursorPaths } from './cursor.js';
-export const MINT_PROVIDER = {
-    claude: 'claude_code',
-    codex: 'codex',
-    cursor: 'cursor',
-};
-async function onPath(name) {
-    const raw = process.env.PATH;
-    if (raw === undefined || raw.trim() === '')
-        return false;
-    const exts = process.platform === 'win32'
-        ? (process.env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)
-        : [''];
-    for (const dir of raw.split(delimiter)) {
-        if (dir === '')
-            continue;
-        for (const ext of exts) {
-            try {
-                await access(join(dir, `${name}${ext}`), constants.X_OK);
-                return true;
-            }
-            catch {
-            }
-        }
-    }
-    return false;
-}
-async function dirExists(path) {
-    try {
-        return (await stat(path)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-export async function detectAgents(home = homedir()) {
-    const [claudeDir, claudeBin, codexDir, codexBin, cursorDir, cursorBin, cursorAgentBin] = await Promise.all([
-        dirExists(join(home, '.claude')),
-        onPath('claude'),
-        dirExists(resolveCodexPaths(home).codexDir),
-        onPath('codex'),
-        dirExists(resolveCursorPaths(home).cursorDir),
-        onPath('cursor'),
-        onPath('cursor-agent'),
-    ]);
-    return {
-        claude: claudeDir || claudeBin,
-        codex: codexDir || codexBin,
-        cursor: cursorDir || cursorBin || cursorAgentBin,
-    };
-}
-export function selectAgents(present, flags = {}) {
-    const codex = flags.codex ?? present.codex;
-    const cursor = flags.cursor ?? present.cursor;
-    const agents = [];
-    if (present.claude)
-        agents.push('claude');
-    if (codex)
-        agents.push('codex');
-    if (cursor)
-        agents.push('cursor');
-    if (agents.length === 0)
-        return { agents: ['claude'], fellBack: true };
-    return { agents, fellBack: false };
-}

package/dist/providers/hook-coverage.d.ts

@@ -1,5 +0,0 @@
-export declare const CODEX_CAPABILITY_BY_EVENT: Readonly<Record<string, readonly string[]>>;
-export declare const CURSOR_CAPABILITY_BY_EVENT: Readonly<Record<string, readonly string[]>>;
-export declare function missingCapabilities(missing: readonly string[], capabilities?: Readonly<Record<string, readonly string[]>>): readonly string[];
-export declare function describeMissingHookEvents(missing: readonly string[], capabilities?: Readonly<Record<string, readonly string[]>>): string;
-export declare function describePartialHooks(covered: number, total: number, missing: readonly string[], capabilities?: Readonly<Record<string, readonly string[]>>): string;

package/dist/providers/hook-coverage.js

@@ -1,47 +0,0 @@
-const CAPABILITY_BY_EVENT = {
-    UserPromptSubmit: ['recall'],
-    SessionEnd: ['the end-of-session report'],
-    Stop: ['capture'],
-    PostToolUse: ['tool context'],
-    PreToolUse: ['tool context'],
-    SessionStart: ['recall after a compaction'],
-};
-export const CODEX_CAPABILITY_BY_EVENT = {
-    ...CAPABILITY_BY_EVENT,
-    Stop: ['capture', 'the end-of-session report'],
-    PostCompact: ['recall after a compaction'],
-};
-export const CURSOR_CAPABILITY_BY_EVENT = {
-    sessionStart: ['recall'],
-    preCompact: ['recall after a compaction'],
-    sessionEnd: ['the end-of-session report'],
-    stop: ['capture'],
-    postToolUse: ['tool context', 'recall after a compaction'],
-    preToolUse: ['tool context'],
-};
-function joinWords(parts) {
-    if (parts.length <= 1)
-        return parts[0] ?? '';
-    return `${parts.slice(0, -1).join(', ')} and ${parts[parts.length - 1]}`;
-}
-export function missingCapabilities(missing, capabilities = CAPABILITY_BY_EVENT) {
-    const seen = new Set();
-    const names = [];
-    for (const event of missing) {
-        for (const name of capabilities[event] ?? [event]) {
-            if (seen.has(name))
-                continue;
-            seen.add(name);
-            names.push(name);
-        }
-    }
-    return names;
-}
-export function describeMissingHookEvents(missing, capabilities) {
-    return joinWords(missingCapabilities(missing, capabilities));
-}
-export function describePartialHooks(covered, total, missing, capabilities) {
-    const names = missingCapabilities(missing, capabilities);
-    const verb = names.length === 1 ? 'is' : 'are';
-    return `${covered} of ${total} events registered — ${joinWords(names)} ${verb} not wired`;
-}

package/dist/providers/hook-entry.d.ts

@@ -1 +0,0 @@
-export declare function isUnrunnableCommandEntry(entry: unknown): boolean;

package/dist/providers/hook-entry.js

@@ -1,8 +0,0 @@
-export function isUnrunnableCommandEntry(entry) {
-    if (entry === null || typeof entry !== 'object' || Array.isArray(entry))
-        return false;
-    const record = entry;
-    if (record.type !== 'command')
-        return false;
-    return typeof record.command !== 'string' || record.command.trim() === '';
-}

package/dist/providers/surfaces.d.ts

@@ -1,19 +0,0 @@
-import { type AgentId, type AgentPresence } from './detect.js';
-export declare const SKILL_FILE = "SKILL.md";
-export declare const AGENT_ROOT: Record<AgentId, (home: string) => string>;
-export declare const SKILL_ROOT: Record<AgentId, (home: string) => string>;
-export declare const DOCS_ROOT: Record<AgentId, (home: string) => string>;
-export declare const REPO_AGENT_DIR: Record<AgentId, string>;
-export declare const REPO_SKILL_DIR: Record<AgentId, string>;
-export declare const REPO_SKILL_LANE = ".<agent>/skills/";
-export declare const AGENT_LABEL: Record<AgentId, string>;
-export interface SkillRoot {
-    readonly agent: AgentId;
-    readonly dir: string;
-}
-export declare function resolveSkillRoots(home?: string, presence?: AgentPresence): Promise<SkillRoot[]>;
-export declare function resolveDocRoots(home?: string, presence?: AgentPresence): Promise<SkillRoot[]>;
-export declare function resolveRepoSkillRoots(repoPath: string, opts?: {
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}): Promise<SkillRoot[]>;

package/dist/providers/surfaces.js

@@ -1,91 +0,0 @@
-import { access, readdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { MANIFEST_FILE } from '../documents/manifest.js';
-import { resolveCodexPaths } from './codex.js';
-import { resolveCursorPaths } from './cursor.js';
-import { detectAgents } from './detect.js';
-export const SKILL_FILE = 'SKILL.md';
-export const AGENT_ROOT = {
-    claude: (home) => join(home, '.claude'),
-    codex: (home) => resolveCodexPaths(home).codexDir,
-    cursor: (home) => resolveCursorPaths(home).cursorDir,
-};
-const under = (leaf) => (agent) => (home) => join(AGENT_ROOT[agent](home), leaf);
-export const SKILL_ROOT = {
-    claude: under('skills')('claude'),
-    codex: under('skills')('codex'),
-    cursor: under('skills')('cursor'),
-};
-export const DOCS_ROOT = {
-    claude: under('docs')('claude'),
-    codex: under('docs')('codex'),
-    cursor: under('docs')('cursor'),
-};
-export const REPO_AGENT_DIR = {
-    claude: '.claude',
-    codex: '.codex',
-    cursor: '.cursor',
-};
-export const REPO_SKILL_DIR = {
-    claude: `${REPO_AGENT_DIR.claude}/skills`,
-    codex: `${REPO_AGENT_DIR.codex}/skills`,
-    cursor: `${REPO_AGENT_DIR.cursor}/skills`,
-};
-export const REPO_SKILL_LANE = '.<agent>/skills/';
-export const AGENT_LABEL = {
-    claude: 'Claude',
-    codex: 'Codex',
-    cursor: 'Cursor',
-};
-export async function resolveSkillRoots(home = homedir(), presence) {
-    return resolveRoots(SKILL_ROOT, home, presence ?? (await detectAgents(home)));
-}
-export async function resolveDocRoots(home = homedir(), presence) {
-    return resolveRoots(DOCS_ROOT, home, presence ?? (await detectAgents(home)));
-}
-export async function resolveRepoSkillRoots(repoPath, opts = {}) {
-    const home = opts.home ?? homedir();
-    const present = opts.agents ?? (await detectAgents(home));
-    return resolveRoots(Object.fromEntries(Object.keys(REPO_SKILL_DIR).map((agent) => [
-        agent,
-        (repo) => join(repo, REPO_SKILL_DIR[agent]),
-    ])), repoPath, present, markedSkillDirExists);
-}
-async function resolveRoots(registry, base, present, wroteHere = rootManifestExists) {
-    const roots = [];
-    for (const agent of Object.keys(registry)) {
-        const dir = registry[agent](base);
-        if (agent === 'claude' || present[agent]) {
-            roots.push({ agent, dir });
-            continue;
-        }
-        if (await wroteHere(dir))
-            roots.push({ agent, dir });
-    }
-    return roots;
-}
-async function rootManifestExists(dir) {
-    return exists(join(dir, MANIFEST_FILE));
-}
-async function markedSkillDirExists(dir) {
-    const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
-    if (entries === null)
-        return false;
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        if (await exists(join(dir, entry.name, MANIFEST_FILE)))
-            return true;
-    }
-    return false;
-}
-async function exists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/reclaim.d.ts

@@ -1,17 +0,0 @@
-import type { AgentPresence } from './providers/detect.js';
-import { type SkillResult } from './skills.js';
-import { type DocumentResult } from './documents/write.js';
-import { type PointerResult } from './documents/pointer.js';
-import { type MemoryResult } from './memories.js';
-export interface ReclaimRepoSummary {
-    readonly skills: readonly SkillResult[];
-    readonly documents: readonly DocumentResult[];
-    readonly pointer: readonly PointerResult[];
-    readonly memories: readonly MemoryResult[];
-    readonly status: 'cleaned' | 'nothing_to_do';
-}
-export interface ReclaimOptions {
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}
-export declare function reclaimRepoFiles(repoPath: string, opts?: ReclaimOptions): Promise<ReclaimRepoSummary>;

package/dist/reclaim.js

@@ -1,33 +0,0 @@
-import { join } from 'node:path';
-import { withFileLock } from './lock.js';
-import { removeRepoSkillFiles } from './skills.js';
-import { DOCS_DIR } from './documents/manifest.js';
-import { removeRepoDocumentFiles } from './documents/write.js';
-import { removeRepoPointerLines } from './documents/pointer.js';
-import { removeProjectMemoryFiles } from './memories.js';
-export async function reclaimRepoFiles(repoPath, opts = {}) {
-    const skills = await withFileLock(repoPath, () => removeRepoSkillFiles(repoPath, {
-        ...(opts.home === undefined ? {} : { home: opts.home }),
-        ...(opts.agents === undefined ? {} : { agents: opts.agents }),
-    }));
-    const documents = await withFileLock(join(repoPath, DOCS_DIR), async () => {
-        const removed = await removeRepoDocumentFiles(repoPath);
-        const pointer = await removeRepoPointerLines(repoPath);
-        return { removed, pointer: pointer.results };
-    });
-    const memories = await removeProjectMemoryFiles({
-        projectPath: repoPath,
-        ...(opts.home === undefined ? {} : { home: opts.home }),
-    });
-    return {
-        skills: skills.results,
-        documents: documents.removed.results,
-        pointer: documents.pointer,
-        memories: memories.results,
-        status: skills.status === 'cleaned' ||
-            documents.removed.status === 'cleaned' ||
-            memories.results.length > 0
-            ? 'cleaned'
-            : 'nothing_to_do',
-    };
-}

package/dist/render.d.ts

@@ -1,17 +0,0 @@
-export type CheckState = 'ok' | 'warn' | 'fail' | 'paused' | 'unknown';
-export interface Check {
-    readonly label: string;
-    readonly state: CheckState;
-    readonly detail: string;
-    readonly fix?: string;
-}
-export interface RenderOptions {
-    readonly colour?: boolean;
-    readonly labelWidth?: number;
-}
-export declare function renderCheck(check: Check, opts?: RenderOptions): string;
-export declare function renderChecks(checks: readonly Check[], opts?: RenderOptions): string;
-export declare function exitCodeFor(checks: readonly Check[]): number;
-export declare function checksToJson(checks: readonly Check[]): unknown;
-export declare function relativeTime(target: Date, now?: Date): string;
-export declare function ratio(numerator: number, denominator: number): string;