harborloop 0.3.0 → 0.4.1

package/dist/daemon/tick.js

@@ -1,231 +0,0 @@
-import { refreshRunnerToken } from '../api.js';
-import { refreshCliRelease } from '../cli-release.js';
-import { isExpired, jwtExpiry, readAuth, resolveCredentials, writeAuth, } from '../auth/store.js';
-import { syncEnvPlane } from '../env-sync.js';
-import { syncRepoPlane } from '../repo-sync.js';
-import { readRepoRegistry } from '../repos.js';
-import { EMPTY_PAUSE, readSyncedConfig, resolveArms, } from '../state.js';
-import { buildSyncReport, postSyncReport } from '../sync-report.js';
-import { withTickLease } from './state.js';
-export const REFRESH_WHEN_LESS_THAN_MS = 48 * 60 * 60 * 1000;
-const ok = (detail) => ({ kind: 'ok', detail });
-const skipped = (detail) => ({ kind: 'skipped', detail });
-const failed = (detail) => ({ kind: 'failed', detail });
-const message = (err) => err instanceof Error ? err.message : String(err);
-const countSynced = (rows) => rows.filter((row) => row.status === 'synced').length;
-async function tickCredential(endpoints, source, fetchImpl, now) {
-    if (source === 'env') {
-        return skipped('Using HARBOR_TOKEN from the environment — not ours to rotate.');
-    }
-    const auth = await readAuth();
-    if (!auth)
-        return skipped('Not signed in.');
-    if (isExpired(auth.runnerToken, now)) {
-        return failed("This machine's credential has expired. Run `harbor login` again.");
-    }
-    const expiry = jwtExpiry(auth.runnerToken);
-    const remaining = expiry === null ? null : expiry.getTime() - now.getTime();
-    if (remaining !== null && remaining > REFRESH_WHEN_LESS_THAN_MS) {
-        return skipped(`Credential good for ${Math.floor(remaining / 3_600_000)}h.`);
-    }
-    try {
-        const rotated = await refreshRunnerToken(auth.apiUrl || endpoints.apiUrl, auth.runnerToken, fetchImpl);
-        const current = (await readAuth()) ?? auth;
-        await writeAuth({ ...current, runnerToken: rotated });
-        return ok('Credential rotated.');
-    }
-    catch (err) {
-        return failed(message(err));
-    }
-}
-async function tickEnv(input) {
-    try {
-        const result = await syncEnvPlane(input);
-        if (result.skills.kind === 'error' || result.documents.kind === 'error') {
-            return { arm: failed('Could not fetch this machine’s own bundle.') };
-        }
-        if (result.skills.kind === 'unsupported') {
-            return { arm: skipped('This backend does not serve a personal bundle yet.') };
-        }
-        const skills = countSynced(result.skills.summary.results);
-        const documents = result.documents.kind === 'synced' && result.documents.outcome.kind === 'applied'
-            ? countSynced(result.documents.outcome.documents)
-            : 0;
-        return {
-            arm: ok(`${skills} skills · ${documents} documents.`),
-            ...(result.bundleHash === undefined ? {} : { bundleHash: result.bundleHash }),
-        };
-    }
-    catch (err) {
-        return { arm: failed(message(err)) };
-    }
-}
-function describeRepo(result) {
-    if (result.kind === 'error')
-        return failed(result.message);
-    if (result.kind === 'sync_disabled') {
-        return skipped(result.reason === 'workspace'
-            ? 'Sync is off for this workspace — an admin turns it on in the web app.'
-            : 'Sync is off for this repository.');
-    }
-    const documents = result.documents.kind === 'applied' ? countSynced(result.documents.documents) : 0;
-    return ok(`${countSynced(result.skills.results)} skills · ${countSynced(result.memories.results)} memories · ${documents} documents.`);
-}
-async function tickRepos(input) {
-    const entries = await readRepoRegistry();
-    const out = [];
-    for (const entry of entries) {
-        const base = { path: entry.path, originUrl: entry.originUrl };
-        if (!input.allowlist.has(entry.originUrl)) {
-            out.push({ ...base, outcome: skipped("Not in this machine's allowlist yet.") });
-            continue;
-        }
-        if (!resolveArms(input.pause, entry.originUrl).recall) {
-            out.push({ ...base, outcome: skipped('Paused.') });
-            continue;
-        }
-        try {
-            const result = await syncRepoPlane({
-                apiBase: input.apiBase,
-                workspaceId: input.workspaceId,
-                bearerToken: input.bearerToken,
-                repoPath: entry.path,
-                originUrl: entry.originUrl,
-                ...(input.fetchImpl ? { fetchImpl: input.fetchImpl } : {}),
-                ...(input.home === undefined ? {} : { home: input.home }),
-            });
-            out.push({ ...base, outcome: describeRepo(result) });
-        }
-        catch (err) {
-            out.push({ ...base, outcome: failed(message(err)) });
-        }
-    }
-    return out;
-}
-async function tickReport(input) {
-    try {
-        const report = await buildSyncReport({
-            ...(input.home === undefined ? {} : { home: input.home }),
-            ...(input.bundleHash === undefined ? {} : { bundleHash: input.bundleHash }),
-        });
-        const posted = await postSyncReport({
-            apiBase: input.apiBase,
-            workspaceId: input.workspaceId,
-            bearerToken: input.bearerToken,
-            report,
-            ...(input.fetchImpl ? { fetchImpl: input.fetchImpl } : {}),
-        });
-        if (posted.kind === 'ok')
-            return ok(`${report.files.length} files reported.`);
-        return posted.kind === 'unsupported'
-            ? skipped('This backend does not accept machine reports yet.')
-            : failed(posted.message);
-    }
-    catch (err) {
-        return failed(message(err));
-    }
-}
-export async function runDaemonTick(opts) {
-    const lease = await withTickLease(() => tickPass(opts), opts.lockWaitMs === undefined ? {} : { waitMs: opts.lockWaitMs });
-    return lease.kind === 'ran' ? { kind: 'ran', report: lease.value } : lease;
-}
-async function tickPass(opts) {
-    const clock = opts.now ?? (() => new Date());
-    const startedAt = clock().toISOString();
-    const finish = (parts) => ({
-        startedAt,
-        finishedAt: clock().toISOString(),
-        reason: opts.reason,
-        ...parts,
-    });
-    let credentials;
-    try {
-        credentials = await resolveCredentials(opts.env);
-    }
-    catch (err) {
-        const none = skipped('No usable credential.');
-        return finish({
-            credential: failed(message(err)),
-            env: none,
-            repos: [],
-            report: none,
-        });
-    }
-    if (!credentials) {
-        const nope = skipped('Not signed in — run `harbor login`.');
-        return finish({ credential: nope, env: nope, repos: [], report: nope });
-    }
-    const credential = await tickCredential(opts.endpoints, credentials.source, opts.fetchImpl, clock());
-    const stored = credentials.source === 'file' ? await readAuth() : null;
-    const bearer = stored?.runnerToken ?? credentials.runnerToken;
-    const apiBase = stored?.apiUrl ?? opts.endpoints.apiUrl;
-    const config = await readSyncedConfig();
-    const pause = config?.pause ?? EMPTY_PAUSE;
-    const passthrough = {
-        ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
-        ...(opts.home === undefined ? {} : { home: opts.home }),
-    };
-    const env = pause.global === 'off'
-        ? { arm: skipped('Paused globally — `harbor on` resumes.') }
-        : await tickEnv({
-            apiBase,
-            workspaceId: credentials.workspaceId,
-            bearerToken: bearer,
-            ...passthrough,
-        });
-    const repos = await tickRepos({
-        apiBase,
-        workspaceId: credentials.workspaceId,
-        bearerToken: bearer,
-        allowlist: new Set(config?.origins ?? []),
-        pause,
-        ...passthrough,
-    });
-    const report = await tickReport({
-        apiBase,
-        workspaceId: credentials.workspaceId,
-        bearerToken: bearer,
-        ...(env.bundleHash === undefined ? {} : { bundleHash: env.bundleHash }),
-        ...passthrough,
-    });
-    const release = await tickRelease(passthrough.fetchImpl, clock());
-    return finish({
-        credential,
-        env: env.arm,
-        repos,
-        report,
-        release,
-        ...(env.bundleHash === undefined ? {} : { bundleHash: env.bundleHash }),
-    });
-}
-async function tickRelease(fetchImpl, now) {
-    try {
-        const check = await refreshCliRelease({ now, ...(fetchImpl ? { fetchImpl } : {}) });
-        switch (check.kind) {
-            case 'checked':
-            case 'cached':
-                return ok(check.release.behind
-                    ? `${check.release.latest} available - this machine runs ${check.release.current}.`
-                    : `Up to date (${check.release.current}).`);
-            case 'unknown-version':
-                return skipped('This build cannot read its own version.');
-            default:
-                return skipped('Could not reach the npm registry.');
-        }
-    }
-    catch (err) {
-        return failed(message(err));
-    }
-}
-export function summarise(report) {
-    return {
-        at: report.finishedAt,
-        reason: report.reason,
-        durationMs: new Date(report.finishedAt).getTime() - new Date(report.startedAt).getTime(),
-        credential: report.credential,
-        env: report.env,
-        repos: report.repos.length,
-        reposFailed: report.repos.filter((r) => r.outcome.kind === 'failed').length,
-        report: report.report,
-    };
-}

package/dist/documents/apply.d.ts

@@ -1,21 +0,0 @@
-import type { AgentPresence } from '../providers/detect.js';
-import { type DocumentPayload, type DocumentResult, type DocumentRootSummary } from './write.js';
-import { type PointerResult } from './pointer.js';
-export interface ApplyDocumentsOptions {
-    readonly workspaceId?: string;
-}
-export type ApplyDocumentsOutcome = {
-    readonly kind: 'unsupported';
-} | {
-    readonly kind: 'applied';
-    readonly dir: string;
-    readonly documents: readonly DocumentResult[];
-    readonly pointer: readonly PointerResult[];
-    readonly reclaimed: boolean;
-    readonly roots?: readonly DocumentRootSummary[];
-};
-export declare function applyDocumentsToRepo(repoPath: string, documents: readonly DocumentPayload[] | undefined, options?: ApplyDocumentsOptions): Promise<ApplyDocumentsOutcome>;
-export declare function applyDocumentsToEnv(documents: readonly DocumentPayload[] | undefined, options?: ApplyDocumentsOptions & {
-    readonly home?: string;
-    readonly agents?: AgentPresence;
-}): Promise<ApplyDocumentsOutcome>;

package/dist/documents/apply.js

@@ -1,58 +0,0 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { withFileLock } from '../lock.js';
-import { DOCS_DIR } from './manifest.js';
-import { syncDocumentFilesToEnv, syncDocumentFilesToRepo, } from './write.js';
-import { removeEnvPointerLines, removeRepoPointerLines, syncPointerLineToEnv, syncPointerLineToRepo, } from './pointer.js';
-export async function applyDocumentsToRepo(repoPath, documents, options = {}) {
-    if (documents === undefined)
-        return { kind: 'unsupported' };
-    return withFileLock(join(repoPath, DOCS_DIR), async () => {
-        const synced = await syncDocumentFilesToRepo(repoPath, documents, {
-            ...(options.workspaceId === undefined ? {} : { workspaceId: options.workspaceId }),
-        });
-        let pointer = [];
-        if (documents.length > 0) {
-            pointer = (await syncPointerLineToRepo(repoPath, true)).results;
-        }
-        else if (synced.reclaimed) {
-            pointer = (await removeRepoPointerLines(repoPath)).results;
-        }
-        return {
-            kind: 'applied',
-            dir: synced.dir,
-            documents: synced.results,
-            pointer,
-            reclaimed: synced.reclaimed,
-        };
-    });
-}
-export async function applyDocumentsToEnv(documents, options = {}) {
-    if (documents === undefined)
-        return { kind: 'unsupported' };
-    const home = options.home ?? homedir();
-    return withFileLock(join(home, DOCS_DIR), async () => {
-        const synced = await syncDocumentFilesToEnv(documents, {
-            home,
-            ...(options.agents === undefined ? {} : { agents: options.agents }),
-            ...(options.workspaceId === undefined
-                ? {}
-                : { workspaceId: options.workspaceId }),
-        });
-        let pointer = [];
-        if (documents.length > 0) {
-            pointer = (await syncPointerLineToEnv(synced.roots, true, { home })).results;
-        }
-        else if (synced.reclaimed) {
-            pointer = (await removeEnvPointerLines(synced.roots, { home })).results;
-        }
-        return {
-            kind: 'applied',
-            dir: synced.dir,
-            documents: synced.results,
-            roots: synced.roots,
-            pointer,
-            reclaimed: synced.reclaimed,
-        };
-    });
-}

package/dist/documents/bundle.d.ts

@@ -1,41 +0,0 @@
-export interface ContextBundlePayload {
-    readonly id: string;
-    readonly name: string;
-    readonly content: string;
-}
-export interface ContextBundleSkill extends ContextBundlePayload {
-    readonly path?: string;
-}
-export interface ContextBundleDocument {
-    readonly id: string;
-    readonly name: string;
-    readonly path: string;
-    readonly content: string;
-}
-export interface ContextBundle {
-    readonly contentHash: string;
-    readonly skills: ReadonlyArray<ContextBundleSkill>;
-    readonly memories: ReadonlyArray<ContextBundlePayload>;
-    readonly documents?: ReadonlyArray<ContextBundleDocument>;
-    readonly lastUpdated: string;
-}
-export type FetchBundleResult = {
-    readonly kind: 'ok';
-    readonly bundle: ContextBundle;
-} | {
-    readonly kind: 'sync_disabled';
-    readonly reason: 'workspace' | 'admin';
-} | {
-    readonly kind: 'error';
-    readonly status: number | 'network';
-    readonly message: string;
-};
-export interface FetchBundleInput {
-    readonly apiBase: string;
-    readonly workspaceId: string;
-    readonly originUrl: string;
-    readonly bearerToken: string;
-    readonly fetchImpl?: typeof fetch;
-}
-export declare function contextBundleUrl(apiBase: string, workspaceId: string, originUrl: string): string;
-export declare function fetchContextBundle(input: FetchBundleInput): Promise<FetchBundleResult>;

package/dist/documents/bundle.js

@@ -1,43 +0,0 @@
-import { ApiError, apiRequest } from '../api.js';
-function stripTrailingSlash(s) {
-    return s.endsWith('/') ? s.slice(0, -1) : s;
-}
-export function contextBundleUrl(apiBase, workspaceId, originUrl) {
-    return (`${stripTrailingSlash(apiBase)}/workspaces/${encodeURIComponent(workspaceId)}` +
-        `/context/repo-bindings/context-bundle?originUrl=${encodeURIComponent(originUrl)}`);
-}
-export async function fetchContextBundle(input) {
-    const url = contextBundleUrl(input.apiBase, input.workspaceId, input.originUrl);
-    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 === 403) {
-            const reason = err.body?.reason;
-            return {
-                kind: 'sync_disabled',
-                reason: reason === 'workspace' ? 'workspace' : 'admin',
-            };
-        }
-        return {
-            kind: 'error',
-            status: err.status ?? 'network',
-            message: err.message,
-        };
-    }
-}

package/dist/documents/inspect.d.ts

@@ -1,12 +0,0 @@
-export type DocumentState = 'ours' | 'forked' | 'missing' | 'unverifiable';
-export interface DocumentStatus {
-    readonly file: string;
-    readonly state: DocumentState;
-}
-export interface RepoDocuments {
-    readonly dir: string;
-    readonly managed: boolean;
-    readonly documents: readonly DocumentStatus[];
-}
-export declare function inspectRepoDocuments(repoRoot: string): Promise<RepoDocuments>;
-export declare function inState(docs: RepoDocuments, state: DocumentState): readonly string[];

package/dist/documents/inspect.js

@@ -1,33 +0,0 @@
-import { promises as fsp } from 'node:fs';
-import { join } from 'node:path';
-import { DOCS_DIR, MANIFEST_FILE, hashDocument, parseManifest, } from './manifest.js';
-export async function inspectRepoDocuments(repoRoot) {
-    const dir = join(repoRoot, DOCS_DIR);
-    const raw = await fsp
-        .readFile(join(dir, MANIFEST_FILE), 'utf8')
-        .catch(() => null);
-    if (raw === null)
-        return { dir, managed: false, documents: [] };
-    const { files, hashes } = parseManifest(raw);
-    const documents = [];
-    for (const file of files) {
-        const content = await fsp.readFile(join(dir, file), 'utf8').catch(() => null);
-        if (content === null) {
-            documents.push({ file, state: 'missing' });
-            continue;
-        }
-        const recorded = hashes.get(file);
-        if (recorded === undefined) {
-            documents.push({ file, state: 'unverifiable' });
-            continue;
-        }
-        documents.push({
-            file,
-            state: hashDocument(content) === recorded ? 'ours' : 'forked',
-        });
-    }
-    return { dir, managed: true, documents };
-}
-export function inState(docs, state) {
-    return docs.documents.filter((d) => d.state === state).map((d) => d.file);
-}

package/dist/documents/manifest.d.ts

@@ -1,14 +0,0 @@
-export declare const DOCS_DIR = ".claude/docs";
-export declare const MANIFEST_FILE = ".milestone-managed";
-export interface ManifestEntry {
-    readonly file: string;
-    readonly sha256: string | null;
-}
-export interface ParsedManifest {
-    readonly files: readonly string[];
-    readonly hashes: ReadonlyMap<string, string>;
-    readonly workspaceId: string | null;
-}
-export declare function hashDocument(content: string): string;
-export declare function parseManifest(raw: string): ParsedManifest;
-export declare function renderManifest(entries: readonly ManifestEntry[], workspaceId?: string | null): string;

package/dist/documents/manifest.js

@@ -1,52 +0,0 @@
-import { createHash } from 'node:crypto';
-export const DOCS_DIR = '.claude/docs';
-export const MANIFEST_FILE = '.milestone-managed';
-const HEADER = [
-    '# Files in this directory that harbor maintains.',
-    '# Anything not listed here was written by a human and is never touched.',
-];
-const HASH_PREFIX = '# sha256 ';
-const HASH_LINE = /^#\s*sha256\s+([0-9a-f]{64})\s+(.+)$/;
-const WORKSPACE_PREFIX = '# workspace: ';
-export function hashDocument(content) {
-    return createHash('sha256').update(content, 'utf8').digest('hex');
-}
-export function parseManifest(raw) {
-    const files = [];
-    const hashes = new Map();
-    let workspaceId = null;
-    for (const line of raw.split('\n')) {
-        const trimmed = line.trim();
-        if (trimmed.length === 0)
-            continue;
-        if (trimmed.startsWith('#')) {
-            const match = trimmed.match(HASH_LINE);
-            if (match) {
-                hashes.set(match[2].trim(), match[1]);
-            }
-            else if (trimmed.startsWith(WORKSPACE_PREFIX)) {
-                workspaceId = trimmed.slice(WORKSPACE_PREFIX.length).trim() || null;
-            }
-            continue;
-        }
-        files.push(trimmed);
-    }
-    for (const file of hashes.keys()) {
-        if (!files.includes(file))
-            hashes.delete(file);
-    }
-    return { files, hashes, workspaceId };
-}
-export function renderManifest(entries, workspaceId) {
-    const names = entries.map((entry) => entry.file);
-    const digests = entries
-        .filter((entry) => entry.sha256 !== null)
-        .map((entry) => `${HASH_PREFIX}${entry.sha256}  ${entry.file}`);
-    return [
-        ...HEADER,
-        ...(workspaceId ? [`${WORKSPACE_PREFIX}${workspaceId}`] : []),
-        ...names,
-        ...digests,
-        '',
-    ].join('\n');
-}

package/dist/documents/pointer.d.ts

@@ -1,32 +0,0 @@
-import type { AgentId } from '../providers/detect.js';
-export declare const POINTER_LINE = "Team documents are in `.claude/docs/` \u2014 read the relevant one when it applies.";
-export type PointerResult = {
-    readonly file: string;
-    readonly status: 'added';
-} | {
-    readonly file: string;
-    readonly status: 'present';
-} | {
-    readonly file: string;
-    readonly status: 'created';
-} | {
-    readonly file: string;
-    readonly status: 'removed';
-};
-export interface PointerSyncSummary {
-    readonly results: readonly PointerResult[];
-}
-export declare function syncPointerLineToRepo(repoPath: string, hasDocuments: boolean): Promise<PointerSyncSummary>;
-export declare function removeRepoPointerLines(repoPath: string): Promise<PointerSyncSummary>;
-export declare const HOME_AGENT_FILE: Record<AgentId, string | null>;
-export declare function homePointerLine(docsDir: string, home?: string): string;
-export interface PointerRoot {
-    readonly agent: AgentId;
-    readonly dir: string;
-}
-export declare function syncPointerLineToEnv(roots: readonly PointerRoot[], hasDocuments: boolean, options?: {
-    readonly home?: string;
-}): Promise<PointerSyncSummary>;
-export declare function removeEnvPointerLines(roots: readonly PointerRoot[], options?: {
-    readonly home?: string;
-}): Promise<PointerSyncSummary>;

package/dist/documents/pointer.js

@@ -1,135 +0,0 @@
-import { existsSync, promises as fsp } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { writeFileAtomic } from '../lock.js';
-import { AGENT_ROOT } from '../providers/surfaces.js';
-export const POINTER_LINE = 'Team documents are in `.claude/docs/` — read the relevant one when it applies.';
-const DOCS_PATH_TOKEN = '.claude/docs/';
-const AGENT_FILES = ['AGENTS.md', 'CLAUDE.md'];
-const NEW_FILE_BODY = `# Agent instructions\n\n${POINTER_LINE}\n`;
-async function readIfExists(path) {
-    return fsp.readFile(path, 'utf8').catch(() => null);
-}
-export async function syncPointerLineToRepo(repoPath, hasDocuments) {
-    if (!existsSync(repoPath)) {
-        throw new Error(`Repo path does not exist: ${repoPath}`);
-    }
-    if (!hasDocuments)
-        return { results: [] };
-    const existing = AGENT_FILES.filter((name) => existsSync(join(repoPath, name)));
-    if (existing.length === 0) {
-        const target = join(repoPath, AGENT_FILES[0]);
-        await writeFileAtomic(target, NEW_FILE_BODY, { mode: 'preserve' });
-        return { results: [{ file: AGENT_FILES[0], status: 'created' }] };
-    }
-    const results = [];
-    for (const name of existing) {
-        const target = join(repoPath, name);
-        const current = await readIfExists(target);
-        if (current === null)
-            continue;
-        if (current.includes(DOCS_PATH_TOKEN)) {
-            results.push({ file: name, status: 'present' });
-            continue;
-        }
-        const separator = current.endsWith('\n\n') ? '' : current.endsWith('\n') ? '\n' : '\n\n';
-        await writeFileAtomic(target, `${current}${separator}${POINTER_LINE}\n`, {
-            mode: 'preserve',
-        });
-        results.push({ file: name, status: 'added' });
-    }
-    return { results };
-}
-export async function removeRepoPointerLines(repoPath) {
-    const results = [];
-    for (const name of AGENT_FILES) {
-        const target = join(repoPath, name);
-        const current = await readIfExists(target);
-        if (current === null)
-            continue;
-        const lines = current.split('\n');
-        const kept = lines.filter((line) => line.trim() !== POINTER_LINE);
-        if (kept.length === lines.length)
-            continue;
-        const rebuilt = kept.join('\n').replace(/\n{3,}$/, '\n\n').replace(/\n+$/, '\n');
-        await writeFileAtomic(target, rebuilt, { mode: 'preserve' });
-        results.push({ file: name, status: 'removed' });
-    }
-    return { results };
-}
-export const HOME_AGENT_FILE = {
-    claude: 'CLAUDE.md',
-    codex: 'AGENTS.md',
-    cursor: null,
-};
-const HOME_FILE_HEADING = '# Agent instructions';
-function displayDocsDir(docsDir, home) {
-    const prefix = home.endsWith('/') ? home : `${home}/`;
-    return docsDir.startsWith(prefix)
-        ? `~/${docsDir.slice(prefix.length)}/`
-        : `${docsDir}/`;
-}
-export function homePointerLine(docsDir, home = homedir()) {
-    return `Your team's documents are in \`${displayDocsDir(docsDir, home)}\` — read the relevant one when it applies.`;
-}
-function homeAgentFilePath(root, home) {
-    const name = HOME_AGENT_FILE[root.agent];
-    return name === null ? null : join(AGENT_ROOT[root.agent](home), name);
-}
-export async function syncPointerLineToEnv(roots, hasDocuments, options = {}) {
-    if (!hasDocuments)
-        return { results: [] };
-    const home = options.home ?? homedir();
-    const results = [];
-    for (const root of roots) {
-        const target = homeAgentFilePath(root, home);
-        if (target === null)
-            continue;
-        const line = homePointerLine(root.dir, home);
-        const current = await readIfExists(target);
-        if (current === null) {
-            await fsp.mkdir(AGENT_ROOT[root.agent](home), { recursive: true });
-            await writeFileAtomic(target, `${HOME_FILE_HEADING}\n\n${line}\n`, {
-                mode: 'preserve',
-            });
-            results.push({ file: target, status: 'created' });
-            continue;
-        }
-        if (current.includes(displayDocsDir(root.dir, home))) {
-            results.push({ file: target, status: 'present' });
-            continue;
-        }
-        const separator = current.endsWith('\n\n') ? '' : current.endsWith('\n') ? '\n' : '\n\n';
-        await writeFileAtomic(target, `${current}${separator}${line}\n`, {
-            mode: 'preserve',
-        });
-        results.push({ file: target, status: 'added' });
-    }
-    return { results };
-}
-export async function removeEnvPointerLines(roots, options = {}) {
-    const home = options.home ?? homedir();
-    const results = [];
-    for (const root of roots) {
-        const target = homeAgentFilePath(root, home);
-        if (target === null)
-            continue;
-        const current = await readIfExists(target);
-        if (current === null)
-            continue;
-        const line = homePointerLine(root.dir, home);
-        const lines = current.split('\n');
-        const kept = lines.filter((entry) => entry.trim() !== line);
-        if (kept.length === lines.length)
-            continue;
-        const rebuilt = kept.join('\n').replace(/\n{3,}$/, '\n\n').replace(/\n+$/, '\n');
-        if (rebuilt.trim() === '' || rebuilt.trim() === HOME_FILE_HEADING) {
-            await fsp.unlink(target).catch(() => undefined);
-        }
-        else {
-            await writeFileAtomic(target, rebuilt, { mode: 'preserve' });
-        }
-        results.push({ file: target, status: 'removed' });
-    }
-    return { results };
-}