harborloop 0.3.0 → 0.4.1

package/dist/commands/toggle.d.ts

@@ -1,16 +0,0 @@
-export interface ToggleOptions {
-    readonly cwd: string;
-    readonly captureOnly?: boolean;
-    readonly receiptOnly?: boolean;
-    readonly global?: boolean;
-}
-export interface ToggleResult {
-    readonly scope: 'repo' | 'global' | 'receipt';
-    readonly originUrl: string | null;
-    readonly recall: boolean;
-    readonly capture: boolean;
-    readonly receipt: boolean;
-}
-export declare function runOff(opts: ToggleOptions): Promise<ToggleResult>;
-export declare function runOn(opts: ToggleOptions): Promise<ToggleResult>;
-export declare function renderToggle(result: ToggleResult): string;

package/dist/commands/toggle.js

@@ -1,69 +0,0 @@
-import { repoOrigin } from '../origin.js';
-import { resolveArms, updateSyncedConfig, withGlobalPause, withReceipt, withRepoPause, } from '../state.js';
-import { NotARepoError } from './bind.js';
-async function applyRepo(cwd, mode) {
-    const origin = repoOrigin(cwd);
-    if (origin === '')
-        throw new NotARepoError(cwd);
-    const config = await updateSyncedConfig((current) => withRepoPause(current, origin, mode));
-    return {
-        scope: 'repo',
-        originUrl: origin,
-        ...resolveArms(config.pause, origin),
-        receipt: config.receipt,
-    };
-}
-async function applyReceipt(cwd, receipt) {
-    const config = await updateSyncedConfig((current) => withReceipt(current, receipt));
-    const origin = repoOrigin(cwd);
-    return {
-        scope: 'receipt',
-        originUrl: origin === '' ? null : origin,
-        ...resolveArms(config.pause, origin === '' ? ' no-repo' : origin),
-        receipt: config.receipt,
-    };
-}
-async function applyGlobal(mode) {
-    const config = await updateSyncedConfig((current) => withGlobalPause(current, mode));
-    const arms = resolveArms(config.pause, ' no-repo');
-    return { scope: 'global', originUrl: null, ...arms, receipt: config.receipt };
-}
-export function runOff(opts) {
-    if (opts.receiptOnly)
-        return applyReceipt(opts.cwd, false);
-    const mode = opts.captureOnly ? 'capture' : 'off';
-    return opts.global ? applyGlobal(mode) : applyRepo(opts.cwd, mode);
-}
-export async function runOn(opts) {
-    if (opts.receiptOnly)
-        return applyReceipt(opts.cwd, true);
-    if (opts.global)
-        return applyGlobal(null);
-    const origin = repoOrigin(opts.cwd);
-    if (origin === '')
-        throw new NotARepoError(opts.cwd);
-    const config = await updateSyncedConfig((current) => withRepoPause(current, origin, current.pause.global === null ? null : 'on'));
-    return {
-        scope: 'repo',
-        originUrl: origin,
-        ...resolveArms(config.pause, origin),
-        receipt: config.receipt,
-    };
-}
-export function renderToggle(result) {
-    if (result.scope === 'receipt') {
-        const state = result.receipt
-            ? 'This machine: the receipt is on. You will see which rules reached the agent.'
-            : 'This machine: the receipt is off. Rules still reach the agent, silently.';
-        return `${state}\n${renderArms(result)}`;
-    }
-    return renderArms(result);
-}
-function renderArms(result) {
-    const where = result.scope === 'repo' ? `This repo (${result.originUrl})` : 'This machine';
-    if (result.recall && result.capture)
-        return `${where}: recall on, recording on.`;
-    if (result.recall)
-        return `${where}: recall on, recording off.`;
-    return `${where}: paused. No context in, nothing recorded.`;
-}

package/dist/commands/unbind.d.ts

@@ -1,14 +0,0 @@
-import { type ReclaimRepoSummary } from '../reclaim.js';
-import type { AgentPresence } from '../providers/detect.js';
-export interface UnbindOptions {
-    readonly cwd: string;
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}
-export interface UnbindResult {
-    readonly repoPath: string;
-    readonly originUrl: string | null;
-    readonly summary: ReclaimRepoSummary;
-}
-export declare function runUnbind(opts: UnbindOptions): Promise<UnbindResult>;
-export declare function renderUnbind(result: UnbindResult): string;

package/dist/commands/unbind.js

@@ -1,60 +0,0 @@
-import { gitRoot, repoOrigin } from '../origin.js';
-import { reclaimRepoFiles } from '../reclaim.js';
-import { DOCS_DIR } from '../documents/manifest.js';
-import { REPO_SKILL_LANE } from '../providers/surfaces.js';
-export async function runUnbind(opts) {
-    const repoPath = gitRoot(opts.cwd) ?? opts.cwd;
-    const origin = repoOrigin(opts.cwd);
-    const summary = await reclaimRepoFiles(repoPath, {
-        ...(opts.home === undefined ? {} : { home: opts.home }),
-        ...(opts.agents === undefined ? {} : { agents: opts.agents }),
-    });
-    return { repoPath, originUrl: origin === '' ? null : origin, summary };
-}
-export function renderUnbind(result) {
-    const { summary } = result;
-    const lines = [];
-    const count = (n, one, many) => `${n} ${n === 1 ? one : many}`;
-    const removed = (rows) => rows.filter((r) => r.status === 'removed').length;
-    const totalRemoved = removed(summary.skills) +
-        removed(summary.documents) +
-        removed(summary.pointer) +
-        removed(summary.memories);
-    if (totalRemoved === 0) {
-        lines.push(`Nothing left to take back from ${result.repoPath}.`);
-    }
-    else {
-        lines.push(`Unbound ${result.repoPath} from this machine.`);
-        const skills = removed(summary.skills);
-        if (skills > 0) {
-            lines.push(`${count(skills, 'skill', 'skills')} removed from ${REPO_SKILL_LANE}`);
-        }
-        const documents = removed(summary.documents);
-        if (documents > 0) {
-            lines.push(`${count(documents, 'document', 'documents')} removed from ${DOCS_DIR}`);
-        }
-        for (const pointer of summary.pointer) {
-            if (pointer.status !== 'removed')
-                continue;
-            lines.push(`Pointer line removed from ${pointer.file}`);
-        }
-        const memories = removed(summary.memories);
-        if (memories > 0) {
-            lines.push(`${count(memories, 'team memory', 'team memories')} removed from your Claude Code memory for this repo`);
-        }
-    }
-    const forked = [
-        ...summary.skills.filter((r) => r.status === 'forked').map((r) => r.dir ?? r.file),
-        ...summary.documents.filter((r) => r.status === 'forked').map((r) => r.file),
-    ].filter((name) => name !== undefined);
-    for (const name of forked) {
-        lines.push(`  ${name} — you edited this one; left in place, not deleted`);
-    }
-    if (result.originUrl !== null) {
-        lines.push('');
-        lines.push(`Still bound in your workspace (${result.originUrl}) — \`harbor sync\`, or the desktop app if it syncs this repo, would write the team's files here again.`);
-        lines.push('Remove the binding itself in the webapp, under Repositories.');
-    }
-    lines.push('Recall and capture are unchanged — `harbor off` pauses this repo.');
-    return lines.join('\n');
-}

package/dist/commands/workspaces.d.ts

@@ -1,18 +0,0 @@
-import type { Endpoints } from '../endpoints.js';
-export interface WorkspacesOptions {
-    readonly endpoints: Endpoints;
-    readonly fetchImpl?: typeof fetch;
-}
-export interface WorkspaceRow {
-    readonly id: string;
-    readonly name: string;
-    readonly current: boolean;
-}
-export interface WorkspacesResult {
-    readonly workspaces: readonly WorkspaceRow[];
-    readonly currentId: string;
-    readonly currentIsStale: boolean;
-    readonly currentIsPending: boolean;
-}
-export declare function runWorkspaces(opts: WorkspacesOptions): Promise<WorkspacesResult>;
-export declare function renderWorkspaces(result: WorkspacesResult): string;

package/dist/commands/workspaces.js

@@ -1,41 +0,0 @@
-import { listWorkspaces } from '../api.js';
-import { isPendingWorkspace, readAuth } from '../auth/store.js';
-import { NotSignedInError } from './bind.js';
-export async function runWorkspaces(opts) {
-    const auth = await readAuth();
-    if (!auth)
-        throw new NotSignedInError();
-    const pending = isPendingWorkspace(auth);
-    const workspaces = await listWorkspaces(opts.endpoints.apiUrl, auth.runnerToken, opts.fetchImpl);
-    return {
-        workspaces: workspaces.map((w) => ({
-            id: w.id,
-            name: w.name,
-            current: w.id === auth.workspaceId,
-        })),
-        currentId: auth.workspaceId,
-        currentIsStale: !pending && !workspaces.some((w) => w.id === auth.workspaceId),
-        currentIsPending: pending,
-    };
-}
-export function renderWorkspaces(result) {
-    if (result.workspaces.length === 0) {
-        return 'This account is not a member of any workspace. Create one in the webapp first.';
-    }
-    const width = Math.max(...result.workspaces.map((w) => w.name.length));
-    const lines = result.workspaces.map((w) => {
-        const marker = w.current ? '*' : ' ';
-        return `  ${marker} ${w.name.padEnd(width)}  ${w.id}`;
-    });
-    if (result.currentIsPending) {
-        lines.push('', '  ⚠ This machine is signed in but has no workspace yet. Choose one with', '    the command below — the browser is not needed again.');
-    }
-    else if (result.currentIsStale) {
-        lines.push('', `  ⚠ This machine is signed in to ${result.currentId}, which is not in the list`, '    above — you are no longer a member. Switch to one that is.');
-    }
-    const switchable = result.workspaces.filter((w) => !w.current);
-    if (switchable.length > 0 || result.currentIsStale || result.currentIsPending) {
-        lines.push('', `${result.currentIsPending ? 'Choose with' : 'Switch with'}:  harbor login --workspace <id>`);
-    }
-    return lines.join('\n');
-}

package/dist/context-budget.d.ts

@@ -1,40 +0,0 @@
-import { type AgentId, type AgentPresence } from './providers/detect.js';
-export type Owner = 'harbor' | 'other-tool' | 'nobody';
-export interface BudgetLine {
-    readonly id: 'skills' | 'skills-dark' | 'agents' | 'agent-files' | 'mcp' | 'injected';
-    readonly label: string;
-    readonly count: number | null;
-    readonly tokens: number | null;
-    readonly unmeasured?: string;
-    readonly note?: string;
-}
-export interface SkillEntry {
-    readonly name: string;
-    readonly path: string;
-    readonly owner: Owner;
-    readonly tokens: number;
-    readonly undiscoverable: boolean;
-    readonly copies: number;
-}
-export interface ContextBudget {
-    readonly lines: readonly BudgetLine[];
-    readonly measuredTokens: number;
-    readonly unmeasuredLines: number;
-    readonly skills: readonly SkillEntry[];
-    readonly ownership: Record<Owner, number>;
-    readonly undiscoverable: number;
-}
-export declare function estimateTokens(text: string): number;
-export declare function indexCost(name: string, description: string): number;
-export declare function readFrontmatter(content: string): {
-    name: string;
-    description: string;
-};
-export declare function collapseCopies(skills: readonly SkillEntry[]): SkillEntry[];
-export interface ContextBudgetOptions {
-    readonly home?: string;
-    readonly repoPath?: string | null;
-    readonly agents?: AgentPresence;
-}
-export declare function measureContext(options?: ContextBudgetOptions): Promise<ContextBudget>;
-export declare function presentAgents(present: AgentPresence): AgentId[];

package/dist/context-budget.js

@@ -1,259 +0,0 @@
-import { promises as fsp } from 'node:fs';
-import { homedir } from 'node:os';
-import { basename, join } from 'node:path';
-import { MANIFEST_FILE, parseManifest } from './documents/manifest.js';
-import { resolveCodexPaths } from './providers/codex.js';
-import { detectAgents } from './providers/detect.js';
-import { AGENT_ROOT, REPO_AGENT_DIR, SKILL_FILE, resolveRepoSkillRoots, resolveSkillRoots, } from './providers/surfaces.js';
-export function estimateTokens(text) {
-    return Math.ceil(text.length / 4);
-}
-const INDEX_ROW_OVERHEAD = 6;
-export function indexCost(name, description) {
-    return estimateTokens(name) + estimateTokens(description) + INDEX_ROW_OVERHEAD;
-}
-export function readFrontmatter(content) {
-    const trimmed = content.trimStart();
-    if (!trimmed.startsWith('---'))
-        return { name: '', description: '' };
-    const end = trimmed.indexOf('\n---', 3);
-    const block = end === -1 ? trimmed : trimmed.slice(0, end);
-    const scalar = (key) => {
-        const match = block.match(new RegExp(`^${key}:\\s*(.*)$`, 'm'));
-        return match?.[1]?.trim().replace(/^["']|["']$/g, '') ?? '';
-    };
-    return { name: scalar('name'), description: scalar('description') };
-}
-async function skillsUnder(dir, owner) {
-    const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => null);
-    if (entries === null)
-        return [];
-    const found = [];
-    for (const entry of entries) {
-        const path = entry.isDirectory()
-            ? join(dir, entry.name, SKILL_FILE)
-            : join(dir, entry.name);
-        if (!entry.isDirectory() && !entry.name.endsWith('.md'))
-            continue;
-        const content = await fsp.readFile(path, 'utf8').catch(() => null);
-        if (content === null)
-            continue;
-        const { name, description } = readFrontmatter(content);
-        found.push({
-            name: entry.isDirectory() ? entry.name : basename(entry.name, '.md'),
-            path,
-            owner,
-            tokens: indexCost(name || entry.name, description),
-            undiscoverable: description.trim().length === 0,
-            copies: 1,
-        });
-    }
-    return found;
-}
-async function ourFiles(dir) {
-    const raw = await fsp.readFile(join(dir, MANIFEST_FILE), 'utf8').catch(() => null);
-    if (raw === null)
-        return new Set();
-    return new Set(parseManifest(raw).files);
-}
-const PLUGIN_DIR = 'plugins';
-async function pluginSkillRoots(claudeDir) {
-    const root = join(claudeDir, PLUGIN_DIR);
-    const found = [];
-    const walk = async (dir, depth) => {
-        const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => null);
-        if (entries === null)
-            return;
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            if (entry.name === 'skills') {
-                found.push(join(dir, entry.name));
-                continue;
-            }
-            if (depth > 0)
-                await walk(join(dir, entry.name), depth - 1);
-        }
-    };
-    await walk(root, 2);
-    return found;
-}
-async function agentDefinitions(dir) {
-    const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => null);
-    if (entries === null)
-        return [];
-    const costs = [];
-    for (const entry of entries) {
-        if (entry.isDirectory() || !entry.name.endsWith('.md'))
-            continue;
-        const content = await fsp.readFile(join(dir, entry.name), 'utf8').catch(() => null);
-        if (content === null)
-            continue;
-        const { name, description } = readFrontmatter(content);
-        costs.push(indexCost(name || entry.name, description));
-    }
-    return costs;
-}
-async function wholeFileTokens(path) {
-    const content = await fsp.readFile(path, 'utf8').catch(() => null);
-    return content === null ? null : estimateTokens(content);
-}
-async function countMcpServers(claudeDir, repoPath) {
-    let total = 0;
-    const fromJson = async (path, key) => {
-        const raw = await fsp.readFile(path, 'utf8').catch(() => null);
-        if (raw === null)
-            return 0;
-        try {
-            const root = JSON.parse(raw);
-            if (root === null || typeof root !== 'object')
-                return 0;
-            const servers = root[key];
-            if (servers === null || typeof servers !== 'object')
-                return 0;
-            return Object.keys(servers).length;
-        }
-        catch {
-            return 0;
-        }
-    };
-    total += await fromJson(join(claudeDir, 'settings.json'), 'mcpServers');
-    total += await fromJson(join(claudeDir, 'mcp.json'), 'mcpServers');
-    if (repoPath)
-        total += await fromJson(join(repoPath, '.mcp.json'), 'mcpServers');
-    const codexConfig = await fsp
-        .readFile(resolveCodexPaths().configTomlPath, 'utf8')
-        .catch(() => null);
-    if (codexConfig !== null) {
-        total += (codexConfig.match(/^\[mcp_servers\.[^\]]+\]/gm) ?? []).length;
-    }
-    return total;
-}
-export function collapseCopies(skills) {
-    const byKey = new Map();
-    for (const skill of skills) {
-        const key = `${skill.name}\u0000${skill.owner}`;
-        const seen = byKey.get(key);
-        if (seen === undefined) {
-            byKey.set(key, skill);
-            continue;
-        }
-        byKey.set(key, {
-            ...seen,
-            tokens: Math.max(seen.tokens, skill.tokens),
-            undiscoverable: seen.undiscoverable && skill.undiscoverable,
-            copies: seen.copies + skill.copies,
-        });
-    }
-    return Array.from(byKey.values());
-}
-export async function measureContext(options = {}) {
-    const home = options.home ?? homedir();
-    const repoPath = options.repoPath ?? null;
-    const present = options.agents ?? (await detectAgents(home));
-    const claudeDir = AGENT_ROOT.claude(home);
-    const found = [];
-    for (const root of await resolveSkillRoots(home, present)) {
-        const ours = await ourFiles(root.dir);
-        for (const skill of await skillsUnder(root.dir, 'nobody')) {
-            const rel = skill.path.slice(root.dir.length + 1);
-            found.push(ours.has(rel) ? { ...skill, owner: 'harbor' } : skill);
-        }
-    }
-    if (repoPath) {
-        for (const root of await resolveRepoSkillRoots(repoPath, { home, agents: present })) {
-            for (const skill of await skillsUnder(root.dir, 'nobody')) {
-                const marked = await fsp
-                    .access(join(root.dir, skill.name, MANIFEST_FILE))
-                    .then(() => true)
-                    .catch(() => false);
-                found.push(marked ? { ...skill, owner: 'harbor' } : skill);
-            }
-        }
-    }
-    for (const pluginRoot of await pluginSkillRoots(claudeDir)) {
-        found.push(...(await skillsUnder(pluginRoot, 'other-tool')));
-    }
-    const agentCosts = [
-        ...(await agentDefinitions(join(claudeDir, 'agents'))),
-        ...(repoPath
-            ? await agentDefinitions(join(repoPath, REPO_AGENT_DIR.claude, 'agents'))
-            : []),
-    ];
-    const agentFilePaths = [
-        join(claudeDir, 'CLAUDE.md'),
-        join(resolveCodexPaths(home).codexDir, 'AGENTS.md'),
-        ...(repoPath ? [join(repoPath, 'CLAUDE.md'), join(repoPath, 'AGENTS.md')] : []),
-    ];
-    const agentFileTokens = [];
-    for (const path of agentFilePaths) {
-        const tokens = await wholeFileTokens(path);
-        if (tokens !== null)
-            agentFileTokens.push(tokens);
-    }
-    const mcpServers = await countMcpServers(claudeDir, repoPath);
-    const skills = collapseCopies(found);
-    const indexed = skills.filter((skill) => !skill.undiscoverable);
-    const undiscoverable = skills.length - indexed.length;
-    const ownership = {
-        harbor: indexed.filter((s) => s.owner === 'harbor').length,
-        'other-tool': indexed.filter((s) => s.owner === 'other-tool').length,
-        nobody: indexed.filter((s) => s.owner === 'nobody').length,
-    };
-    const lines = [
-        {
-            id: 'skills',
-            label: 'skills index',
-            count: indexed.length,
-            tokens: indexed.reduce((sum, skill) => sum + skill.tokens, 0),
-            note: `${ownership.harbor} managed by harbor · ${ownership.nobody} unowned · ${ownership['other-tool']} from other tools`,
-        },
-        {
-            id: 'skills-dark',
-            label: 'skill files not indexed',
-            count: undiscoverable,
-            tokens: null,
-            unmeasured: undiscoverable > 0
-                ? 'no description — nothing can select them, and nothing here can price them'
-                : 'none',
-        },
-        {
-            id: 'agents',
-            label: 'agent definitions',
-            count: agentCosts.length,
-            tokens: agentCosts.reduce((sum, cost) => sum + cost, 0),
-        },
-        {
-            id: 'agent-files',
-            label: 'agent files',
-            count: agentFileTokens.length,
-            tokens: agentFileTokens.reduce((sum, cost) => sum + cost, 0),
-        },
-        {
-            id: 'mcp',
-            label: 'MCP tools',
-            count: mcpServers,
-            tokens: null,
-            unmeasured: 'tool descriptions live on the server — connect to price them',
-            note: `${mcpServers} server${mcpServers === 1 ? '' : 's'} configured`,
-        },
-        {
-            id: 'injected',
-            label: 'injected context',
-            count: null,
-            tokens: null,
-            unmeasured: 'varies per session — no on-disk record to read',
-        },
-    ];
-    return {
-        lines,
-        measuredTokens: lines.reduce((sum, line) => sum + (line.tokens ?? 0), 0),
-        unmeasuredLines: lines.filter((line) => line.tokens === null).length,
-        skills,
-        ownership,
-        undiscoverable,
-    };
-}
-export function presentAgents(present) {
-    return Object.keys(present).filter((agent) => present[agent]);
-}

package/dist/daemon/install.d.ts

@@ -1,50 +0,0 @@
-export declare const LAUNCHD_LABEL = "com.harbor.daemon";
-export declare const SYSTEMD_UNIT = "harbor-daemon";
-export type InstallPlatform = 'darwin' | 'linux' | 'unsupported';
-export declare function installPlatform(platform?: string): InstallPlatform;
-export interface DaemonProgram {
-    readonly interpreter: string;
-    readonly script: string;
-}
-export declare function daemonProgram(argv?: readonly string[], execPath?: string): DaemonProgram;
-export declare function launchAgentPath(home?: string): string;
-export declare function systemdDir(home?: string): string;
-export declare function launchAgentPlist(program: DaemonProgram, harborHome: string, intervalSeconds?: number): string;
-export declare function systemdService(program: DaemonProgram): string;
-export declare function systemdTimer(intervalSeconds?: number): string;
-export interface InstallPlan {
-    readonly platform: InstallPlatform;
-    readonly files: readonly {
-        readonly path: string;
-        readonly body: string;
-    }[];
-    readonly activate: readonly (readonly string[])[];
-    readonly deactivate: readonly (readonly string[])[];
-}
-export declare function installPlan(input: {
-    readonly program: DaemonProgram;
-    readonly harborHome: string;
-    readonly home?: string;
-    readonly platform?: InstallPlatform;
-    readonly uid?: number;
-}): InstallPlan;
-export interface InstallOutcome {
-    readonly kind: 'installed' | 'removed' | 'unsupported' | 'partial';
-    readonly files: readonly string[];
-    readonly manual: readonly (readonly string[])[];
-    readonly detail: string;
-}
-export type Runner = (argv: readonly string[]) => Promise<{
-    readonly ok: boolean;
-    readonly message: string;
-}>;
-export declare const spawnRunner: Runner;
-export declare function installDaemon(input: {
-    readonly plan: InstallPlan;
-    readonly run?: Runner;
-}): Promise<InstallOutcome>;
-export declare function uninstallDaemon(input: {
-    readonly plan: InstallPlan;
-    readonly run?: Runner;
-}): Promise<InstallOutcome>;
-export declare function installedFiles(plan: InstallPlan): Promise<readonly string[]>;