harborloop 0.3.0 → 0.4.1

package/dist/render.js

@@ -1,61 +0,0 @@
-const GLYPH = {
-    ok: '✓',
-    warn: '⚠',
-    fail: '✗',
-    paused: '⏸',
-    unknown: '·',
-};
-function colour(state, text, enabled) {
-    if (!enabled)
-        return text;
-    const code = state === 'ok' ? 32 : state === 'warn' ? 33 : state === 'fail' ? 31 : 90;
-    return `\u001b[${code}m${text}\u001b[0m`;
-}
-export function renderCheck(check, opts = {}) {
-    const useColour = opts.colour ?? Boolean(process.stdout.isTTY);
-    const width = opts.labelWidth ?? 14;
-    const label = check.label.padEnd(width);
-    const glyph = colour(check.state, GLYPH[check.state], useColour);
-    const line = `  ${label} ${glyph} ${check.detail}`;
-    return check.fix ? `${line}\n  ${' '.repeat(width)}   ↳ ${check.fix}` : line;
-}
-export function renderChecks(checks, opts = {}) {
-    const labelWidth = opts.labelWidth ?? Math.max(...checks.map((c) => c.label.length), 0);
-    return checks.map((c) => renderCheck(c, { ...opts, labelWidth })).join('\n');
-}
-export function exitCodeFor(checks) {
-    return checks.some((c) => c.state === 'fail') ? 1 : 0;
-}
-export function checksToJson(checks) {
-    return checks.map((c) => ({
-        label: c.label,
-        state: c.state,
-        detail: c.detail,
-        ...(c.fix ? { fix: c.fix } : {}),
-    }));
-}
-export function relativeTime(target, now = new Date()) {
-    const deltaMs = target.getTime() - now.getTime();
-    const future = deltaMs >= 0;
-    const abs = Math.abs(deltaMs);
-    const units = [
-        [365 * 24 * 60 * 60 * 1000, 'year'],
-        [24 * 60 * 60 * 1000, 'day'],
-        [60 * 60 * 1000, 'hour'],
-        [60 * 1000, 'minute'],
-    ];
-    for (const [ms, name] of units) {
-        if (abs >= ms) {
-            const n = Math.round(abs / ms);
-            const plural = n === 1 ? name : `${name}s`;
-            return future ? `in ${n} ${plural}` : `${n} ${plural} ago`;
-        }
-    }
-    return 'just now';
-}
-export function ratio(numerator, denominator) {
-    if (denominator <= 0)
-        return `${numerator} of 0`;
-    const pct = Math.round((numerator / denominator) * 100);
-    return `${numerator} of ${denominator} (${pct}%)`;
-}

package/dist/repo-sync.d.ts

@@ -1,27 +0,0 @@
-import { type ApplyDocumentsOutcome } from './documents/apply.js';
-import { type MemorySyncSummary } from './memories.js';
-import type { AgentPresence } from './providers/detect.js';
-import { type SkillSyncSummary } from './skills.js';
-export interface RepoSyncOptions {
-    readonly apiBase: string;
-    readonly workspaceId: string;
-    readonly bearerToken: string;
-    readonly repoPath: string;
-    readonly originUrl: string;
-    readonly fetchImpl?: typeof fetch;
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}
-export type RepoSyncResult = {
-    readonly kind: 'synced';
-    readonly documents: ApplyDocumentsOutcome;
-    readonly skills: SkillSyncSummary;
-    readonly memories: MemorySyncSummary;
-} | {
-    readonly kind: 'sync_disabled';
-    readonly reason: 'workspace' | 'admin';
-} | {
-    readonly kind: 'error';
-    readonly message: string;
-};
-export declare function syncRepoPlane(opts: RepoSyncOptions): Promise<RepoSyncResult>;

package/dist/repo-sync.js

@@ -1,34 +0,0 @@
-import { applyDocumentsToRepo } from './documents/apply.js';
-import { fetchContextBundle } from './documents/bundle.js';
-import { syncMemoryFilesToHome } from './memories.js';
-import { syncSkillFilesToRepo } from './skills.js';
-export async function syncRepoPlane(opts) {
-    const fetched = await fetchContextBundle({
-        apiBase: opts.apiBase,
-        workspaceId: opts.workspaceId,
-        originUrl: opts.originUrl,
-        bearerToken: opts.bearerToken,
-        ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
-    });
-    if (fetched.kind === 'sync_disabled') {
-        return { kind: 'sync_disabled', reason: fetched.reason };
-    }
-    if (fetched.kind === 'error') {
-        return { kind: 'error', message: fetched.message };
-    }
-    const bundle = fetched.bundle;
-    const documents = await applyDocumentsToRepo(opts.repoPath, bundle.documents, {
-        workspaceId: opts.workspaceId,
-    });
-    const skills = await syncSkillFilesToRepo(opts.repoPath, bundle.skills, {
-        workspaceId: opts.workspaceId,
-        ...(opts.home === undefined ? {} : { home: opts.home }),
-        ...(opts.agents === undefined ? {} : { agents: opts.agents }),
-    });
-    const memories = await syncMemoryFilesToHome({
-        projectPath: opts.repoPath,
-        memories: bundle.memories,
-        ...(opts.home === undefined ? {} : { home: opts.home }),
-    });
-    return { kind: 'synced', documents, skills, memories };
-}

package/dist/repos.d.ts

@@ -1,11 +0,0 @@
-export interface RepoEntry {
-    readonly originUrl: string;
-    readonly path: string;
-    readonly addedAt: string;
-}
-export declare function repoRegistryFile(): string;
-export declare function parseRepoRegistry(raw: string): readonly RepoEntry[];
-export declare function readRepoRegistry(): Promise<readonly RepoEntry[]>;
-export declare function rememberRepo(entry: RepoEntry): Promise<readonly RepoEntry[]>;
-export declare function noteCheckout(originUrl: string, path: string, now?: Date): Promise<void>;
-export declare function forgetRepo(path: string): Promise<readonly RepoEntry[]>;

package/dist/repos.js

@@ -1,82 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { ensureConfigDir, updateFileLocked } from './lock.js';
-import { normalizeOriginUrl } from './origin.js';
-import { harborDir } from './paths.js';
-export function repoRegistryFile() {
-    return join(harborDir(), 'repos.json');
-}
-function parseEntry(raw) {
-    if (raw === null || typeof raw !== 'object')
-        return [];
-    const obj = raw;
-    const originUrl = typeof obj.originUrl === 'string' ? normalizeOriginUrl(obj.originUrl) : '';
-    const path = typeof obj.path === 'string' ? obj.path : '';
-    if (originUrl === '' || path === '')
-        return [];
-    return [
-        {
-            originUrl,
-            path,
-            addedAt: typeof obj.addedAt === 'string' ? obj.addedAt : '',
-        },
-    ];
-}
-export function parseRepoRegistry(raw) {
-    if (raw.trim() === '')
-        return [];
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return [];
-    }
-    if (parsed === null || typeof parsed !== 'object')
-        return [];
-    const rows = parsed.repos;
-    if (!Array.isArray(rows))
-        return [];
-    return dedupe(rows.flatMap(parseEntry));
-}
-export async function readRepoRegistry() {
-    try {
-        return parseRepoRegistry(await readFile(repoRegistryFile(), 'utf8'));
-    }
-    catch {
-        return [];
-    }
-}
-function dedupe(entries) {
-    const byPath = new Map();
-    for (const entry of entries)
-        byPath.set(entry.path, entry);
-    return [...byPath.values()];
-}
-async function update(change) {
-    await ensureConfigDir(harborDir());
-    let next = [];
-    await updateFileLocked(repoRegistryFile(), (existing) => {
-        next = dedupe(change(parseRepoRegistry(existing)));
-        const body = { version: 1, repos: next };
-        return `${JSON.stringify(body, null, 2)}\n`;
-    });
-    return next;
-}
-export async function rememberRepo(entry) {
-    return update((entries) => [...entries, entry]);
-}
-export async function noteCheckout(originUrl, path, now = new Date()) {
-    try {
-        await rememberRepo({
-            originUrl: normalizeOriginUrl(originUrl),
-            path,
-            addedAt: now.toISOString(),
-        });
-    }
-    catch {
-    }
-}
-export async function forgetRepo(path) {
-    return update((entries) => entries.filter((entry) => entry.path !== path));
-}

package/dist/skills.d.ts

@@ -1,84 +0,0 @@
-import type { AgentId, AgentPresence } from './providers/detect.js';
-export declare const SKILLS_DIR = ".claude/skills";
-export interface SkillPayload {
-    readonly id: string;
-    readonly name: string;
-    readonly path?: string;
-    readonly content: string;
-}
-export type SkillResult = {
-    readonly id: string;
-    readonly file?: string;
-    readonly dir?: string;
-    readonly status: 'synced';
-} | {
-    readonly id: string;
-    readonly file?: string;
-    readonly dir?: string;
-    readonly status: 'skipped_theirs';
-} | {
-    readonly id?: string;
-    readonly file?: string;
-    readonly dir?: string;
-    readonly status: 'forked';
-} | {
-    readonly file?: string;
-    readonly dir?: string;
-    readonly status: 'removed';
-};
-export interface SkillRootSummary {
-    readonly agent: AgentId;
-    readonly dir: string;
-    readonly results: readonly SkillResult[];
-    readonly reclaimed: boolean;
-}
-export interface SkillSyncSummary {
-    readonly dir: string;
-    readonly results: readonly SkillResult[];
-    readonly reclaimed: boolean;
-}
-export interface EnvSkillSyncSummary extends SkillSyncSummary {
-    readonly roots: readonly SkillRootSummary[];
-}
-export interface SkillSyncOptions {
-    readonly workspaceId?: string;
-}
-export declare function syncSkillFilesToEnv(skills: readonly SkillPayload[], opts?: SkillSyncOptions & {
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}): Promise<EnvSkillSyncSummary>;
-export declare function syncSkillFilesToRepo(repoPath: string, skills: readonly SkillPayload[], opts?: SkillSyncOptions & {
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}): Promise<EnvSkillSyncSummary>;
-export type SkillState = 'ours' | 'forked' | 'missing' | 'unverifiable';
-export interface SkillStatus {
-    readonly name: string;
-    readonly state: SkillState;
-}
-export interface ManagedSkills {
-    readonly dir: string;
-    readonly managed: boolean;
-    readonly skills: readonly SkillStatus[];
-}
-export declare function inspectRepoSkillRoots(repoRoot: string, opts?: {
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}): Promise<ManagedSkillRoot[]>;
-export declare function inspectRepoSkills(repoRoot: string): Promise<ManagedSkills>;
-export interface ManagedSkillRoot extends ManagedSkills {
-    readonly agent: AgentId;
-}
-export declare function inspectEnvSkillRoots(opts?: {
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}): Promise<ManagedSkillRoot[]>;
-export declare function skillsInState(managed: ManagedSkills, state: SkillState): readonly string[];
-export declare function removeRepoSkillFiles(repoPath: string, opts?: {
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}): Promise<{
-    readonly dir: string;
-    readonly results: readonly SkillResult[];
-    readonly status: 'cleaned' | 'no_dir';
-}>;

package/dist/skills.js

@@ -1,383 +0,0 @@
-import { existsSync, promises as fsp } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { MANIFEST_FILE, hashDocument, parseManifest, renderManifest, } from './documents/manifest.js';
-import { writeFileAtomic } from './lock.js';
-import { REPO_SKILL_DIR, SKILL_FILE, resolveRepoSkillRoots, resolveSkillRoots, } from './providers/surfaces.js';
-import { slugify } from './slugify.js';
-export const SKILLS_DIR = '.claude/skills';
-async function ensureDir(path) {
-    await fsp.mkdir(path, { recursive: true, mode: 0o700 });
-    if (process.platform !== 'win32') {
-        try {
-            await fsp.chmod(path, 0o700);
-        }
-        catch {
-        }
-    }
-}
-const EMPTY_CLAIM = {
-    present: false,
-    files: new Set(),
-    hashes: new Map(),
-    workspaceId: null,
-};
-async function readClaim(markerPath) {
-    const raw = await fsp.readFile(markerPath, 'utf8').catch(() => null);
-    if (raw === null)
-        return EMPTY_CLAIM;
-    const parsed = parseManifest(raw);
-    return {
-        present: true,
-        files: new Set(parsed.files),
-        hashes: parsed.hashes,
-        workspaceId: parsed.workspaceId,
-    };
-}
-async function writeClaim(markerPath, entries, workspaceId) {
-    const body = renderManifest(entries, workspaceId ?? null);
-    const current = await fsp.readFile(markerPath, 'utf8').catch(() => null);
-    if (current === body)
-        return;
-    await writeFileAtomic(markerPath, body);
-}
-async function ownershipOf(filePath, file, claim) {
-    const recorded = claim.hashes.get(file);
-    if (recorded === undefined)
-        return 'unknown';
-    const current = await fsp.readFile(filePath, 'utf8').catch(() => null);
-    if (current === null)
-        return 'unknown';
-    return hashDocument(current) === recorded ? 'ours' : 'forked';
-}
-function slugOf(skill) {
-    const fromPath = skill.path
-        ?.split('/')
-        .filter((part) => part.length > 0 && part !== '.' && part !== '..')
-        .filter((part) => part !== SKILL_FILE)
-        .pop()
-        ?.replace(/\.md$/, '');
-    const candidate = (fromPath ?? '').replace(/[/\\]/g, '').trim();
-    const traversal = /^\.+$/.test(candidate);
-    const slug = candidate.length > 0 && !traversal ? candidate : slugify(skill.name);
-    if (slug.length === 0) {
-        throw new Error(`Skill name '${skill.name}' produced an empty slug — provide a name with at least one alphanumeric character`);
-    }
-    return slug;
-}
-export async function syncSkillFilesToEnv(skills, opts = {}) {
-    const home = opts.home ?? homedir();
-    const roots = await resolveSkillRoots(home, opts.agents);
-    const summaries = [];
-    for (const root of roots) {
-        summaries.push({
-            agent: root.agent,
-            ...(await syncSkillsUnderRoot(root.dir, skills, opts)),
-        });
-    }
-    const primary = summaries.find((s) => s.agent === 'claude') ?? summaries[0] ?? null;
-    return {
-        dir: primary?.dir ?? join(home, SKILLS_DIR),
-        results: summaries.flatMap((s) => s.results),
-        reclaimed: summaries.some((s) => s.reclaimed),
-        roots: summaries,
-    };
-}
-async function syncSkillsUnderRoot(skillsDir, skills, opts) {
-    const markerPath = join(skillsDir, MANIFEST_FILE);
-    const previous = await readClaim(markerPath);
-    if (skills.length === 0 && !previous.present) {
-        return { dir: skillsDir, results: [], reclaimed: false };
-    }
-    if (skills.length === 0) {
-        const ours = opts.workspaceId !== undefined &&
-            previous.workspaceId !== null &&
-            previous.workspaceId === opts.workspaceId;
-        if (!ours)
-            return { dir: skillsDir, results: [], reclaimed: false };
-        const results = [];
-        for (const file of previous.files) {
-            if ((await ownershipOf(join(skillsDir, file), file, previous)) === 'forked') {
-                results.push({ file, ...slugPart(file), status: 'forked' });
-                continue;
-            }
-            await removeManagedFile(skillsDir, file);
-            results.push({ file, ...slugPart(file), status: 'removed' });
-        }
-        await fsp.rm(markerPath, { force: true });
-        return { dir: skillsDir, results, reclaimed: true };
-    }
-    await ensureDir(skillsDir);
-    const entries = [];
-    const results = [];
-    for (const skill of skills) {
-        const slug = slugOf(skill);
-        const file = `${slug}/${SKILL_FILE}`;
-        const skillDir = join(skillsDir, slug);
-        const filePath = join(skillDir, SKILL_FILE);
-        if (await isLink(skillDir)) {
-            results.push({ id: skill.id, dir: slug, file, status: 'skipped_theirs' });
-            continue;
-        }
-        const current = await fsp.readFile(filePath, 'utf8').catch(() => null);
-        if (current === skill.content) {
-            entries.push({ file, sha256: hashDocument(skill.content) });
-            results.push({ id: skill.id, dir: slug, file, status: 'synced' });
-            continue;
-        }
-        if (current !== null && !previous.files.has(file)) {
-            results.push({ id: skill.id, dir: slug, file, status: 'skipped_theirs' });
-            continue;
-        }
-        if (current !== null && (await ownershipOf(filePath, file, previous)) === 'forked') {
-            entries.push({ file, sha256: previous.hashes.get(file) ?? null });
-            results.push({ id: skill.id, dir: slug, file, status: 'forked' });
-            continue;
-        }
-        await ensureDir(skillDir);
-        await writeFileAtomic(filePath, skill.content);
-        entries.push({ file, sha256: hashDocument(skill.content) });
-        results.push({ id: skill.id, dir: slug, file, status: 'synced' });
-    }
-    if (!previous.present) {
-        for (const result of results) {
-            if (result.status !== 'synced' || result.dir === undefined)
-                continue;
-            const flat = `${result.dir}.md`;
-            const flatPath = join(skillsDir, flat);
-            if (!(await fsp.stat(flatPath).catch(() => null)))
-                continue;
-            await fsp.rm(flatPath, { force: true });
-            results.push({ dir: result.dir, file: flat, status: 'removed' });
-        }
-    }
-    const keep = new Set(entries.map((entry) => entry.file));
-    for (const stale of previous.files) {
-        if (keep.has(stale))
-            continue;
-        if ((await ownershipOf(join(skillsDir, stale), stale, previous)) === 'forked') {
-            results.push({ ...slugPart(stale), file: stale, status: 'forked' });
-            continue;
-        }
-        await removeManagedFile(skillsDir, stale);
-        results.push({ ...slugPart(stale), file: stale, status: 'removed' });
-    }
-    await writeClaim(markerPath, entries, opts.workspaceId);
-    return { dir: skillsDir, results, reclaimed: false };
-}
-function slugPart(file) {
-    const slash = file.indexOf('/');
-    return slash === -1 ? {} : { dir: file.slice(0, slash) };
-}
-async function removeManagedFile(root, file) {
-    await fsp.rm(join(root, file), { force: true });
-    const parent = slugPart(file).dir;
-    if (parent === undefined)
-        return;
-    await fsp.rmdir(join(root, parent)).catch(() => undefined);
-}
-async function isLink(path) {
-    return await fsp
-        .lstat(path)
-        .then((stats) => stats.isSymbolicLink())
-        .catch(() => false);
-}
-export async function syncSkillFilesToRepo(repoPath, skills, opts = {}) {
-    if (!existsSync(repoPath)) {
-        throw new Error(`Repo path does not exist: ${repoPath}`);
-    }
-    const roots = await resolveRepoSkillRoots(repoPath, {
-        ...(opts.home === undefined ? {} : { home: opts.home }),
-        ...(opts.agents === undefined ? {} : { agents: opts.agents }),
-    });
-    const summaries = [];
-    for (const root of roots) {
-        summaries.push({
-            agent: root.agent,
-            ...(await syncSkillsUnderRepoRoot(root.dir, skills, opts)),
-        });
-    }
-    const primary = summaries.find((s) => s.agent === 'claude') ?? summaries[0] ?? null;
-    return {
-        dir: primary?.dir ?? join(repoPath, REPO_SKILL_DIR.claude),
-        results: summaries.flatMap((s) => s.results),
-        reclaimed: summaries.some((s) => s.reclaimed),
-        roots: summaries,
-    };
-}
-async function syncSkillsUnderRepoRoot(skillsDir, skills, opts) {
-    const expected = new Set();
-    const results = [];
-    if (skills.length > 0)
-        await ensureDir(skillsDir);
-    for (const skill of skills) {
-        const slug = slugOf(skill);
-        expected.add(slug);
-        const skillDir = join(skillsDir, slug);
-        const markerPath = join(skillDir, MANIFEST_FILE);
-        const filePath = join(skillDir, SKILL_FILE);
-        const claim = await readClaim(markerPath);
-        const current = await fsp.readFile(filePath, 'utf8').catch(() => null);
-        if (current !== null && !claim.present) {
-            results.push({ id: skill.id, dir: slug, status: 'skipped_theirs' });
-            continue;
-        }
-        if (current === skill.content) {
-            await writeClaim(markerPath, [{ file: SKILL_FILE, sha256: hashDocument(skill.content) }], opts.workspaceId);
-            results.push({ id: skill.id, dir: slug, status: 'synced' });
-            continue;
-        }
-        if (current !== null &&
-            (await ownershipOf(filePath, SKILL_FILE, claim)) === 'forked') {
-            await writeClaim(markerPath, [{ file: SKILL_FILE, sha256: claim.hashes.get(SKILL_FILE) ?? null }], claim.workspaceId ?? opts.workspaceId);
-            results.push({ id: skill.id, dir: slug, status: 'forked' });
-            continue;
-        }
-        await ensureDir(skillDir);
-        await writeFileAtomic(filePath, skill.content);
-        await writeClaim(markerPath, [{ file: SKILL_FILE, sha256: hashDocument(skill.content) }], opts.workspaceId);
-        results.push({ id: skill.id, dir: slug, status: 'synced' });
-    }
-    const pruned = await pruneRepoSkillDirs(skillsDir, expected, {
-        workspaceId: opts.workspaceId,
-        allowUnstamped: skills.length > 0,
-    });
-    results.push(...pruned);
-    const reclaimed = skills.length === 0 && results.some((r) => r.status === 'removed');
-    return { dir: skillsDir, results, reclaimed };
-}
-async function pruneRepoSkillDirs(skillsDir, expected, opts) {
-    const results = [];
-    const entries = await fsp
-        .readdir(skillsDir, { withFileTypes: true })
-        .catch(() => []);
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        if (expected.has(entry.name))
-            continue;
-        const dirPath = join(skillsDir, entry.name);
-        const claim = await readClaim(join(dirPath, MANIFEST_FILE));
-        if (!claim.present)
-            continue;
-        const stamped = opts.workspaceId !== undefined &&
-            claim.workspaceId !== null &&
-            claim.workspaceId === opts.workspaceId;
-        const otherWorkspace = claim.workspaceId !== null && claim.workspaceId !== opts.workspaceId;
-        if (!stamped && (otherWorkspace || !opts.allowUnstamped))
-            continue;
-        if ((await ownershipOf(join(dirPath, SKILL_FILE), SKILL_FILE, claim)) === 'forked') {
-            results.push({ dir: entry.name, status: 'forked' });
-            continue;
-        }
-        await fsp.rm(dirPath, { recursive: true, force: true });
-        results.push({ dir: entry.name, status: 'removed' });
-    }
-    return results;
-}
-function classify(claim, file, content) {
-    if (content === null)
-        return 'missing';
-    const recorded = claim.hashes.get(file);
-    if (recorded === undefined)
-        return 'unverifiable';
-    return hashDocument(content) === recorded ? 'ours' : 'forked';
-}
-export async function inspectRepoSkillRoots(repoRoot, opts = {}) {
-    const roots = await resolveRepoSkillRoots(repoRoot, opts);
-    const out = [];
-    for (const root of roots) {
-        out.push({ agent: root.agent, ...(await inspectSkillsUnderRoot(root.dir)) });
-    }
-    return out;
-}
-export async function inspectRepoSkills(repoRoot) {
-    return inspectSkillsUnderRoot(join(repoRoot, SKILLS_DIR));
-}
-async function inspectSkillsUnderRoot(dir) {
-    const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => null);
-    if (entries === null)
-        return { dir, managed: false, skills: [] };
-    const skills = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        const skillDir = join(dir, entry.name);
-        const claim = await readClaim(join(skillDir, MANIFEST_FILE));
-        if (!claim.present)
-            continue;
-        const content = await fsp
-            .readFile(join(skillDir, SKILL_FILE), 'utf8')
-            .catch(() => null);
-        skills.push({ name: entry.name, state: classify(claim, SKILL_FILE, content) });
-    }
-    return { dir, managed: skills.length > 0, skills };
-}
-export async function inspectEnvSkillRoots(opts = {}) {
-    const home = opts.home ?? homedir();
-    const roots = await resolveSkillRoots(home, opts.agents);
-    const out = [];
-    for (const root of roots) {
-        const claim = await readClaim(join(root.dir, MANIFEST_FILE));
-        if (!claim.present) {
-            out.push({ agent: root.agent, dir: root.dir, managed: false, skills: [] });
-            continue;
-        }
-        const skills = [];
-        for (const file of claim.files) {
-            const content = await fsp
-                .readFile(join(root.dir, file), 'utf8')
-                .catch(() => null);
-            skills.push({ name: file, state: classify(claim, file, content) });
-        }
-        out.push({ agent: root.agent, dir: root.dir, managed: true, skills });
-    }
-    return out;
-}
-export function skillsInState(managed, state) {
-    return managed.skills.filter((s) => s.state === state).map((s) => s.name);
-}
-export async function removeRepoSkillFiles(repoPath, opts = {}) {
-    if (!existsSync(repoPath)) {
-        throw new Error(`Repo path does not exist: ${repoPath}`);
-    }
-    const roots = await resolveRepoSkillRoots(repoPath, opts);
-    const results = [];
-    const cleaned = [];
-    for (const root of roots) {
-        if (!existsSync(root.dir))
-            continue;
-        results.push(...(await removeSkillsUnderRepoRoot(root.dir)));
-        cleaned.push(root.dir);
-    }
-    const primary = join(repoPath, REPO_SKILL_DIR.claude);
-    if (cleaned.length === 0) {
-        return { dir: primary, results: [], status: 'no_dir' };
-    }
-    return { dir: cleaned.includes(primary) ? primary : cleaned[0], results, status: 'cleaned' };
-}
-async function removeSkillsUnderRepoRoot(skillsDir) {
-    const results = [];
-    const entries = await fsp
-        .readdir(skillsDir, { withFileTypes: true })
-        .catch(() => []);
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        const dirPath = join(skillsDir, entry.name);
-        const claim = await readClaim(join(dirPath, MANIFEST_FILE));
-        if (!claim.present)
-            continue;
-        if ((await ownershipOf(join(dirPath, SKILL_FILE), SKILL_FILE, claim)) === 'forked') {
-            results.push({ dir: entry.name, status: 'forked' });
-            continue;
-        }
-        await fsp.rm(dirPath, { recursive: true, force: true });
-        results.push({ dir: entry.name, status: 'removed' });
-    }
-    const remaining = await fsp.readdir(skillsDir).catch(() => null);
-    if (remaining && remaining.length === 0) {
-        await fsp.rmdir(skillsDir).catch(() => undefined);
-    }
-    return results;
-}

package/dist/slugify.d.ts

@@ -1 +0,0 @@
-export declare function slugify(name: string): string;