harborloop 0.3.0 → 0.4.1

package/dist/documents/write.d.ts

@@ -1,57 +0,0 @@
-import type { AgentId, AgentPresence } from '../providers/detect.js';
-export interface DocumentPayload {
-    readonly id: string;
-    readonly name: string;
-    readonly path: string;
-    readonly content: string;
-}
-export type DocumentResult = {
-    readonly id: string;
-    readonly file: string;
-    readonly status: 'synced';
-} | {
-    readonly id: string;
-    readonly file: string;
-    readonly status: 'skipped_theirs';
-} | {
-    readonly id: string;
-    readonly file: string;
-    readonly status: 'forked';
-} | {
-    readonly file: string;
-    readonly status: 'forked';
-} | {
-    readonly file: string;
-    readonly status: 'removed';
-};
-export interface DocumentRootSummary {
-    readonly agent: AgentId;
-    readonly dir: string;
-    readonly results: readonly DocumentResult[];
-    readonly reclaimed: boolean;
-}
-export interface DocumentSyncSummary {
-    readonly dir: string;
-    readonly results: readonly DocumentResult[];
-    readonly reclaimed: boolean;
-}
-export interface EnvDocumentSyncSummary extends DocumentSyncSummary {
-    readonly roots: readonly DocumentRootSummary[];
-}
-export interface DocumentSyncOptions {
-    readonly workspaceId?: string;
-}
-export declare function syncDocumentFilesToRepo(repoPath: string, documents: readonly DocumentPayload[], options?: DocumentSyncOptions): Promise<DocumentSyncSummary>;
-export declare function syncDocumentFilesToEnv(documents: readonly DocumentPayload[], options?: DocumentSyncOptions & {
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}): Promise<EnvDocumentSyncSummary>;
-export declare function removeRepoDocumentFiles(repoPath: string): Promise<DocumentSyncSummary & {
-    readonly status: 'cleaned' | 'no_dir';
-}>;
-export declare function removeEnvDocumentFiles(options?: {
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}): Promise<DocumentSyncSummary & {
-    readonly status: 'cleaned' | 'no_dir';
-}>;

package/dist/documents/write.js

@@ -1,211 +0,0 @@
-import { existsSync, promises as fsp } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { writeFileAtomic } from '../lock.js';
-import { resolveDocRoots } from '../providers/surfaces.js';
-import { slugify } from '../slugify.js';
-import { DOCS_DIR, MANIFEST_FILE, hashDocument, parseManifest, renderManifest, } from './manifest.js';
-async function readManifest(docsDir) {
-    try {
-        const raw = await fsp.readFile(join(docsDir, MANIFEST_FILE), 'utf8');
-        const parsed = parseManifest(raw);
-        return {
-            files: new Set(parsed.files),
-            hashes: parsed.hashes,
-            workspaceId: parsed.workspaceId,
-        };
-    }
-    catch {
-        return { files: new Set(), hashes: new Map(), workspaceId: null };
-    }
-}
-async function writeManifest(docsDir, entries, workspaceId) {
-    const body = renderManifest(entries, workspaceId ?? null);
-    const path = join(docsDir, MANIFEST_FILE);
-    const current = await fsp.readFile(path, 'utf8').catch(() => null);
-    if (current === body)
-        return;
-    await writeFileAtomic(path, body);
-}
-async function ownershipOf(docsDir, file, manifest) {
-    const recorded = manifest.hashes.get(file);
-    if (recorded === undefined)
-        return 'unknown';
-    const current = await fsp.readFile(join(docsDir, file), 'utf8').catch(() => null);
-    if (current === null)
-        return 'unknown';
-    return hashDocument(current) === recorded ? 'ours' : 'forked';
-}
-async function ensureDir(path) {
-    await fsp.mkdir(path, { recursive: true, mode: 0o700 });
-    if (process.platform !== 'win32') {
-        try {
-            await fsp.chmod(path, 0o700);
-        }
-        catch {
-        }
-    }
-}
-function relativePathFor(document) {
-    const slug = slugify(document.name);
-    const fallback = slug.length > 0 ? `${slug}.md` : `document-${slugify(document.id) || 'unnamed'}.md`;
-    const raw = document.path.trim();
-    if (raw.includes('\\') || raw.startsWith('/'))
-        return fallback;
-    const isOurs = raw.startsWith(`${DOCS_DIR}/`);
-    const segments = (isOurs ? raw.slice(DOCS_DIR.length + 1) : (raw.split('/').pop() ?? ''))
-        .split('/')
-        .filter((segment) => segment.length > 0);
-    if (segments.length === 0 || segments.length > 2)
-        return fallback;
-    if (segments.some((segment) => segment.includes('..')))
-        return fallback;
-    if (!segments[segments.length - 1].endsWith('.md'))
-        return fallback;
-    return segments.join('/');
-}
-async function pruneEmptiedDirs(docsDir, files) {
-    const dirs = new Set();
-    for (const file of files) {
-        const dir = dirname(file);
-        if (dir !== '.' && dir !== '')
-            dirs.add(dir);
-    }
-    for (const dir of dirs) {
-        await fsp.rmdir(join(docsDir, dir)).catch(() => {
-        });
-    }
-}
-async function syncDocumentFilesInDir(docsDir, documents, options = {}) {
-    const previous = await readManifest(docsDir);
-    if (documents.length === 0 && previous.files.size === 0) {
-        return { dir: docsDir, results: [], reclaimed: false };
-    }
-    if (documents.length === 0) {
-        const ours = options.workspaceId !== undefined &&
-            previous.workspaceId !== null &&
-            previous.workspaceId === options.workspaceId;
-        if (!ours) {
-            return { dir: docsDir, results: [], reclaimed: false };
-        }
-        const cleaned = await removeDocumentFilesInDir(docsDir);
-        return { dir: cleaned.dir, results: cleaned.results, reclaimed: true };
-    }
-    await ensureDir(docsDir);
-    const entries = [];
-    const results = [];
-    for (const document of documents) {
-        const fileName = relativePathFor(document);
-        const filePath = join(docsDir, fileName);
-        const current = await fsp.readFile(filePath, 'utf8').catch(() => null);
-        if (current === document.content) {
-            entries.push({ file: fileName, sha256: hashDocument(document.content) });
-            results.push({ id: document.id, file: fileName, status: 'synced' });
-            continue;
-        }
-        if (current !== null && !previous.files.has(fileName)) {
-            results.push({ id: document.id, file: fileName, status: 'skipped_theirs' });
-            continue;
-        }
-        if (current !== null && (await ownershipOf(docsDir, fileName, previous)) === 'forked') {
-            entries.push({
-                file: fileName,
-                sha256: previous.hashes.get(fileName) ?? null,
-            });
-            results.push({ id: document.id, file: fileName, status: 'forked' });
-            continue;
-        }
-        if (fileName.includes('/'))
-            await ensureDir(dirname(filePath));
-        await writeFileAtomic(filePath, document.content);
-        entries.push({ file: fileName, sha256: hashDocument(document.content) });
-        results.push({ id: document.id, file: fileName, status: 'synced' });
-    }
-    const keep = new Set(entries.map((entry) => entry.file));
-    const removed = [];
-    for (const stale of previous.files) {
-        if (keep.has(stale))
-            continue;
-        if ((await ownershipOf(docsDir, stale, previous)) === 'forked') {
-            results.push({ file: stale, status: 'forked' });
-            continue;
-        }
-        await fsp.rm(join(docsDir, stale), { force: true });
-        removed.push(stale);
-        results.push({ file: stale, status: 'removed' });
-    }
-    await pruneEmptiedDirs(docsDir, removed);
-    await writeManifest(docsDir, entries, options.workspaceId);
-    return { dir: docsDir, results, reclaimed: false };
-}
-async function removeDocumentFilesInDir(docsDir) {
-    if (!existsSync(docsDir)) {
-        return { dir: docsDir, results: [], reclaimed: false, status: 'no_dir' };
-    }
-    const manifest = await readManifest(docsDir);
-    const results = [];
-    const removed = [];
-    for (const file of manifest.files) {
-        if ((await ownershipOf(docsDir, file, manifest)) === 'forked') {
-            results.push({ file, status: 'forked' });
-            continue;
-        }
-        await fsp.rm(join(docsDir, file), { force: true });
-        removed.push(file);
-        results.push({ file, status: 'removed' });
-    }
-    await fsp.rm(join(docsDir, MANIFEST_FILE), { force: true });
-    await pruneEmptiedDirs(docsDir, removed);
-    const left = await fsp.readdir(docsDir).catch(() => ['keep']);
-    if (left.length === 0) {
-        await fsp.rm(docsDir, { recursive: true, force: true });
-    }
-    return { dir: docsDir, results, reclaimed: true, status: 'cleaned' };
-}
-export async function syncDocumentFilesToRepo(repoPath, documents, options = {}) {
-    if (!existsSync(repoPath)) {
-        throw new Error(`Path does not exist: ${repoPath}`);
-    }
-    return syncDocumentFilesInDir(join(repoPath, DOCS_DIR), documents, options);
-}
-export async function syncDocumentFilesToEnv(documents, options = {}) {
-    const { home, agents, ...rest } = options;
-    const resolvedHome = home ?? homedir();
-    const roots = await resolveDocRoots(resolvedHome, agents);
-    const summaries = [];
-    for (const root of roots) {
-        summaries.push({
-            agent: root.agent,
-            ...(await syncDocumentFilesInDir(root.dir, documents, rest)),
-        });
-    }
-    const primary = summaries.find((summary) => summary.agent === 'claude') ??
-        summaries[0] ??
-        null;
-    return {
-        dir: primary?.dir ?? join(resolvedHome, DOCS_DIR),
-        results: summaries.flatMap((summary) => summary.results),
-        reclaimed: summaries.some((summary) => summary.reclaimed),
-        roots: summaries,
-    };
-}
-export async function removeRepoDocumentFiles(repoPath) {
-    return removeDocumentFilesInDir(join(repoPath, DOCS_DIR));
-}
-export async function removeEnvDocumentFiles(options = {}) {
-    const home = options.home ?? homedir();
-    const roots = await resolveDocRoots(home, options.agents);
-    const cleaned = [];
-    for (const root of roots) {
-        cleaned.push(await removeDocumentFilesInDir(root.dir));
-    }
-    const primary = cleaned[0];
-    return {
-        dir: primary?.dir ?? join(home, DOCS_DIR),
-        results: cleaned.flatMap((one) => one.results),
-        reclaimed: cleaned.some((one) => one.reclaimed),
-        status: cleaned.some((one) => one.status === 'cleaned')
-            ? 'cleaned'
-            : 'no_dir',
-    };
-}

package/dist/endpoints.d.ts

@@ -1,7 +0,0 @@
-export interface Endpoints {
-    readonly apiUrl: string;
-    readonly mcpUrl: string;
-    readonly webUrl: string;
-}
-export declare function resolveEndpoints(env?: NodeJS.ProcessEnv): Endpoints;
-export declare function isLocalEndpoint(endpoints: Endpoints): boolean;

package/dist/endpoints.js

@@ -1,15 +0,0 @@
-const PROD_API_URL = 'https://app.gethrbr.com/v1';
-const PROD_MCP_URL = 'https://mcp.gethrbr.com/mcp';
-const PROD_WEB_URL = 'https://app.gethrbr.com';
-const strip = (url) => url.replace(/\/+$/, '');
-export function resolveEndpoints(env = process.env) {
-    const read = (suffix) => env[`HARBOR_${suffix}`]?.trim() || env[`ALEF0_${suffix}`]?.trim();
-    return {
-        apiUrl: strip(read('API_URL') || PROD_API_URL),
-        mcpUrl: strip(read('MCP_URL') || PROD_MCP_URL),
-        webUrl: strip(read('WEB_URL') || PROD_WEB_URL),
-    };
-}
-export function isLocalEndpoint(endpoints) {
-    return /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:|\/|$)/i.test(endpoints.apiUrl);
-}

package/dist/env-bundle.d.ts

@@ -1,25 +0,0 @@
-import type { ContextBundleDocument, ContextBundleSkill } from './documents/bundle.js';
-export interface EnvBundle {
-    readonly contentHash: string;
-    readonly skills: ReadonlyArray<ContextBundleSkill>;
-    readonly documents?: ReadonlyArray<ContextBundleDocument>;
-    readonly lastUpdated: string;
-}
-export type FetchEnvBundleResult = {
-    readonly kind: 'ok';
-    readonly bundle: EnvBundle;
-} | {
-    readonly kind: 'unsupported';
-} | {
-    readonly kind: 'error';
-    readonly status: number | 'network';
-    readonly message: string;
-};
-export interface FetchEnvBundleInput {
-    readonly apiBase: string;
-    readonly workspaceId: string;
-    readonly bearerToken: string;
-    readonly fetchImpl?: typeof fetch;
-}
-export declare function envBundleUrl(apiBase: string, workspaceId: string): string;
-export declare function fetchEnvBundle(input: FetchEnvBundleInput): Promise<FetchEnvBundleResult>;

package/dist/env-bundle.js

@@ -1,33 +0,0 @@
-import { ApiError, apiRequest } from './api.js';
-function stripTrailingSlash(s) {
-    return s.endsWith('/') ? s.slice(0, -1) : s;
-}
-export function envBundleUrl(apiBase, workspaceId) {
-    return (`${stripTrailingSlash(apiBase)}/workspaces/${encodeURIComponent(workspaceId)}` +
-        `/context/env-bundle`);
-}
-export async function fetchEnvBundle(input) {
-    const url = envBundleUrl(input.apiBase, input.workspaceId);
-    try {
-        const body = await apiRequest(url, {
-            bearer: input.bearerToken,
-            fetchImpl: input.fetchImpl,
-        });
-        const data = body?.data;
-        if (!data)
-            return { kind: 'error', status: 200, message: 'missing data field' };
-        return { kind: 'ok', bundle: data };
-    }
-    catch (err) {
-        if (!(err instanceof ApiError)) {
-            return {
-                kind: 'error',
-                status: 'network',
-                message: err instanceof Error ? err.message : String(err),
-            };
-        }
-        if (err.status === 404)
-            return { kind: 'unsupported' };
-        return { kind: 'error', status: err.status ?? 'network', message: err.message };
-    }
-}

package/dist/env-scan.d.ts

@@ -1,27 +0,0 @@
-import type { AgentId, AgentPresence } from './providers/detect.js';
-export type ScannedKind = 'SKILL' | 'DOCUMENT';
-export type ScannedState = 'ours' | 'forked' | 'missing' | 'unverifiable';
-export interface ScannedFile {
-    readonly kind: ScannedKind;
-    readonly file: string;
-    readonly sha256: string | null;
-    readonly state: ScannedState;
-}
-export interface ScannedRoot {
-    readonly agent: AgentId;
-    readonly dir: string;
-    readonly managed: boolean;
-    readonly files: readonly ScannedFile[];
-}
-export interface EnvScan {
-    readonly roots: readonly ScannedRoot[];
-}
-export interface EnvScanOptions {
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}
-export declare function scanEnv(options?: EnvScanOptions): Promise<EnvScan>;
-export declare function scannedFiles(scan: EnvScan): ReadonlyArray<ScannedFile & {
-    readonly agent: AgentId;
-    readonly dir: string;
-}>;

package/dist/env-scan.js

@@ -1,41 +0,0 @@
-import { promises as fsp } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { MANIFEST_FILE, hashDocument, parseManifest, } from './documents/manifest.js';
-import { resolveDocRoots, resolveSkillRoots } from './providers/surfaces.js';
-async function classify(dir, file, recorded) {
-    const content = await fsp.readFile(join(dir, file), 'utf8').catch(() => null);
-    if (content === null)
-        return { sha256: null, state: 'missing' };
-    const onDisk = hashDocument(content);
-    if (recorded === undefined)
-        return { sha256: onDisk, state: 'unverifiable' };
-    return { sha256: onDisk, state: onDisk === recorded ? 'ours' : 'forked' };
-}
-async function scanManifestDir(dir, kind) {
-    const raw = await fsp.readFile(join(dir, MANIFEST_FILE), 'utf8').catch(() => null);
-    if (raw === null)
-        return { managed: false, files: [] };
-    const { files, hashes } = parseManifest(raw);
-    const out = [];
-    for (const file of files) {
-        out.push({ kind, file, ...(await classify(dir, file, hashes.get(file))) });
-    }
-    return { managed: true, files: out };
-}
-export async function scanEnv(options = {}) {
-    const home = options.home ?? homedir();
-    const roots = [];
-    for (const root of await resolveSkillRoots(home, options.agents)) {
-        const scanned = await scanManifestDir(root.dir, 'SKILL');
-        roots.push({ agent: root.agent, dir: root.dir, ...scanned });
-    }
-    for (const root of await resolveDocRoots(home, options.agents)) {
-        const scanned = await scanManifestDir(root.dir, 'DOCUMENT');
-        roots.push({ agent: root.agent, dir: root.dir, ...scanned });
-    }
-    return { roots };
-}
-export function scannedFiles(scan) {
-    return scan.roots.flatMap((root) => root.files.map((file) => ({ ...file, agent: root.agent, dir: root.dir })));
-}

package/dist/env-sync.d.ts

@@ -1,31 +0,0 @@
-import { type ApplyDocumentsOutcome } from './documents/apply.js';
-import { type EnvSkillSyncSummary } from './skills.js';
-export type EnvSkillOutcome = {
-    readonly kind: 'synced';
-    readonly summary: EnvSkillSyncSummary;
-} | {
-    readonly kind: 'unsupported';
-} | {
-    readonly kind: 'error';
-};
-export type EnvDocumentOutcome = {
-    readonly kind: 'synced';
-    readonly outcome: ApplyDocumentsOutcome;
-} | {
-    readonly kind: 'unsupported';
-} | {
-    readonly kind: 'error';
-};
-export interface EnvSyncOptions {
-    readonly apiBase: string;
-    readonly workspaceId: string;
-    readonly bearerToken: string;
-    readonly fetchImpl?: typeof fetch;
-    readonly home?: string;
-}
-export interface EnvSyncResult {
-    readonly skills: EnvSkillOutcome;
-    readonly documents: EnvDocumentOutcome;
-    readonly bundleHash?: string;
-}
-export declare function syncEnvPlane(opts: EnvSyncOptions): Promise<EnvSyncResult>;

package/dist/env-sync.js

@@ -1,37 +0,0 @@
-import { applyDocumentsToEnv } from './documents/apply.js';
-import { fetchEnvBundle } from './env-bundle.js';
-import { syncSkillFilesToEnv } from './skills.js';
-export async function syncEnvPlane(opts) {
-    const fetched = await fetchEnvBundle({
-        apiBase: opts.apiBase,
-        workspaceId: opts.workspaceId,
-        bearerToken: opts.bearerToken,
-        ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
-    });
-    if (fetched.kind !== 'ok') {
-        const kind = fetched.kind === 'unsupported' ? 'unsupported' : 'error';
-        return { skills: { kind }, documents: { kind } };
-    }
-    const home = opts.home === undefined ? {} : { home: opts.home };
-    const skills = {
-        kind: 'synced',
-        summary: await syncSkillFilesToEnv(fetched.bundle.skills, {
-            workspaceId: opts.workspaceId,
-            ...home,
-        }),
-    };
-    const documents = {
-        kind: 'synced',
-        outcome: await applyDocumentsToEnv(fetched.bundle.documents, {
-            workspaceId: opts.workspaceId,
-            ...home,
-        }),
-    };
-    return {
-        skills,
-        documents,
-        ...(fetched.bundle.contentHash === undefined
-            ? {}
-            : { bundleHash: fetched.bundle.contentHash }),
-    };
-}

package/dist/index.d.ts

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-export declare const VERBS: readonly ["init", "login", "logout", "bind", "unbind", "sync", "daemon", "status", "workspaces", "doctor", "context", "on", "off", "help", "version"];
-type Verb = (typeof VERBS)[number];
-interface ParsedArgs {
-    readonly verb: Verb;
-    readonly flags: Readonly<Record<string, string | true>>;
-}
-export declare function parseArgs(argv: readonly string[]): ParsedArgs;
-export declare function main(argv: readonly string[]): Promise<number>;
-export declare function isProgramEntry(argv1: string | undefined, moduleUrl: string, resolve?: (path: string) => string): boolean;
-export {};