@open-agent-toolkit/cli 0.0.10

package/dist/drift/strays.js

@@ -0,0 +1,153 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { basename, join, relative, resolve } from 'node:path';
+import { OAT_MARKER_PREFIX } from '../engine/markers.js';
+import { CliError } from '../errors/index.js';
+import { toPosixPath } from '../fs/paths.js';
+import { canonicalRuleNameForProviderEntry } from '../rules/canonical/index.js';
+function inferContentType(providerDir) {
+    const dirName = basename(toPosixPath(providerDir));
+    if (dirName === 'skills') {
+        return 'skill';
+    }
+    if (dirName === 'agents') {
+        return 'agent';
+    }
+    if (dirName === 'rules' || dirName === 'instructions') {
+        return 'rule';
+    }
+    return null;
+}
+export function inferScopeRoot(providerDir) {
+    const normalized = toPosixPath(resolve(providerDir));
+    const segments = normalized.split('/').filter(Boolean);
+    for (let index = segments.length - 2; index >= 0; index -= 1) {
+        const segment = segments[index];
+        const nextSegment = segments[index + 1];
+        if (segment?.startsWith('.') &&
+            (nextSegment === 'skills' ||
+                nextSegment === 'agents' ||
+                nextSegment === 'rules' ||
+                nextSegment === 'instructions')) {
+            const rootPath = `/${segments.slice(0, index).join('/')}`;
+            return rootPath === '' ? '/' : rootPath;
+        }
+    }
+    return resolve(providerDir, '..', '..');
+}
+function toScopeRelative(path, scopeRoot) {
+    return toPosixPath(relative(scopeRoot, resolve(path)));
+}
+function isManifestTracked(providerPathRelative, manifest) {
+    const normalizedProviderPath = toPosixPath(providerPathRelative);
+    return manifest.entries.some((entry) => {
+        const manifestPath = toPosixPath(entry.providerPath);
+        return manifestPath === normalizedProviderPath;
+    });
+}
+function isCanonicalEntry(name, contentType, canonicalEntries) {
+    if (!contentType) {
+        return false;
+    }
+    return canonicalEntries.some((entry) => {
+        return entry.name === name && entry.type === contentType;
+    });
+}
+function isManagedRuleFile(name, mapping) {
+    if (mapping?.contentType === 'rule' && mapping.providerExtension) {
+        return name.endsWith(mapping.providerExtension);
+    }
+    return (name.endsWith('.md') ||
+        name.endsWith('.mdc') ||
+        name.endsWith('.instructions.md'));
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+const GENERATED_RULE_SOURCE_PATTERN = new RegExp(`${escapeRegExp(OAT_MARKER_PREFIX)} Source: ([^\\n]+?) -->\\s*$`);
+function extractGeneratedRuleSource(content) {
+    const match = content.match(GENERATED_RULE_SOURCE_PATTERN);
+    const sourcePath = match?.[1]?.trim();
+    return sourcePath ? toPosixPath(sourcePath) : null;
+}
+async function isGeneratedAdaptedRule(providerPath, mapping) {
+    if (mapping?.contentType !== 'rule') {
+        return false;
+    }
+    let content;
+    try {
+        content = await readFile(providerPath, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    const sourcePath = extractGeneratedRuleSource(content);
+    if (!sourcePath) {
+        return false;
+    }
+    const canonicalDir = '.agents/rules';
+    return (sourcePath === canonicalDir || sourcePath.startsWith(`${canonicalDir}/`));
+}
+async function readProviderEntries(resolvedProviderDir) {
+    try {
+        return await readdir(resolvedProviderDir, {
+            withFileTypes: true,
+            encoding: 'utf8',
+        });
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return [];
+        }
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            (error.code === 'EACCES' || error.code === 'EPERM')) {
+            throw new CliError(`Permission denied reading provider directory ${resolvedProviderDir}. Adjust permissions and retry.`);
+        }
+        throw error;
+    }
+}
+export async function detectStrays(provider, providerDir, manifest, canonicalEntries, mapping) {
+    const contentType = mapping?.contentType ?? inferContentType(providerDir);
+    const scopeRoot = inferScopeRoot(providerDir);
+    const reports = [];
+    const resolvedProviderDir = resolve(providerDir);
+    const entries = await readProviderEntries(resolvedProviderDir);
+    for (const entry of entries) {
+        if (!entry.isDirectory() && !entry.isSymbolicLink() && !entry.isFile()) {
+            continue;
+        }
+        if (entry.isFile() &&
+            !(contentType === 'rule'
+                ? isManagedRuleFile(entry.name, mapping)
+                : entry.name.endsWith('.md'))) {
+            continue;
+        }
+        const providerPath = join(resolvedProviderDir, entry.name);
+        const providerPathRelative = toScopeRelative(providerPath, scopeRoot);
+        if (isManifestTracked(providerPathRelative, manifest)) {
+            continue;
+        }
+        if (entry.isFile() &&
+            (await isGeneratedAdaptedRule(providerPath, mapping))) {
+            continue;
+        }
+        const canonicalName = contentType === 'rule'
+            ? canonicalRuleNameForProviderEntry(entry.name, mapping)
+            : entry.name;
+        if (isCanonicalEntry(canonicalName, contentType, canonicalEntries)) {
+            continue;
+        }
+        reports.push({
+            canonical: null,
+            provider,
+            providerPath: providerPathRelative,
+            state: { status: 'stray' },
+        });
+    }
+    reports.sort((left, right) => left.providerPath.localeCompare(right.providerPath));
+    return reports;
+}

package/dist/engine/compute-plan.d.ts

@@ -0,0 +1,16 @@
+import type { SyncConfig } from '../config/sync-config.js';
+import type { Manifest } from '../manifest/manifest.types.js';
+import type { ProviderAdapter } from '../providers/shared/adapter.types.js';
+import type { EngineScope, SyncPlan } from './engine.types.js';
+import type { CanonicalEntry } from './scanner.js';
+interface ComputeSyncPlanArgs {
+    canonical: CanonicalEntry[];
+    adapters: ProviderAdapter[];
+    manifest: Manifest;
+    scope: EngineScope;
+    config: SyncConfig;
+    scopeRoot?: string;
+}
+export declare function computeSyncPlan({ canonical, adapters, manifest, scope, config, scopeRoot: explicitScopeRoot, }: ComputeSyncPlanArgs): Promise<SyncPlan>;
+export {};
+//# sourceMappingURL=compute-plan.d.ts.map

package/dist/engine/compute-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-plan.d.ts","sourceRoot":"","sources":["../../src/engine/compute-plan.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGtD,OAAO,KAAK,EAAE,QAAQ,EAAiB,MAAM,0BAA0B,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAIvE,OAAO,KAAK,EACV,WAAW,EAEX,QAAQ,EAET,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD,UAAU,mBAAmB;IAC3B,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,EAAE,WAAW,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAoPD,wBAAsB,eAAe,CAAC,EACpC,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,MAAM,EACN,SAAS,EAAE,iBAAiB,GAC7B,EAAE,mBAAmB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAyGzC"}

package/dist/engine/compute-plan.js

@@ -0,0 +1,234 @@
+import { access, lstat, readFile, readlink } from 'node:fs/promises';
+import { basename, dirname, join, normalize, resolve } from 'node:path';
+import { computeContentHash, computeStringHash } from '../manifest/hash.js';
+import { findEntry } from '../manifest/manager.js';
+import { getSyncMappings } from '../providers/shared/adapter.utils.js';
+function buildUpLevels(depth) {
+    return Array.from({ length: depth }, () => '..');
+}
+function segmentDepth(relativePath) {
+    const normalized = relativePath.replaceAll('\\', '/');
+    return normalized.split('/').filter(Boolean).length;
+}
+function canonicalDirectoryName(contentType) {
+    if (contentType === 'skill') {
+        return 'skills';
+    }
+    if (contentType === 'agent') {
+        return 'agents';
+    }
+    return 'rules';
+}
+function canonicalRelativePath(entry) {
+    return join('.agents', canonicalDirectoryName(entry.type), entry.name);
+}
+function providerEntryName(entry, providerExtension) {
+    if (!providerExtension || !entry.isFile) {
+        return entry.name;
+    }
+    return entry.name.replace(/\.md$/, providerExtension);
+}
+function resolveScopeRootFromCanonical(entry, relativeCanonicalPath) {
+    const depth = segmentDepth(relativeCanonicalPath);
+    return resolve(entry.canonicalPath, ...buildUpLevels(depth));
+}
+function entryInsideMapping(entry, mappingCanonicalDir) {
+    const relativeCanonicalPath = canonicalRelativePath(entry).replaceAll('\\', '/');
+    const normalizedMappingCanonicalDir = mappingCanonicalDir.replaceAll('\\', '/');
+    return (relativeCanonicalPath === normalizedMappingCanonicalDir ||
+        relativeCanonicalPath.startsWith(`${normalizedMappingCanonicalDir}/`));
+}
+function resolveStrategy(adapter, config, transformCanonical) {
+    const providerConfig = config.providers[adapter.name];
+    if (providerConfig?.enabled === false) {
+        return null;
+    }
+    if (transformCanonical) {
+        return 'copy';
+    }
+    const configuredStrategy = providerConfig?.strategy ??
+        config.defaultStrategy ??
+        adapter.defaultStrategy;
+    if (configuredStrategy === 'copy') {
+        return 'copy';
+    }
+    if (configuredStrategy === 'symlink') {
+        return 'symlink';
+    }
+    // Auto resolves to symlink at planning time; executeSyncPlan handles
+    // platform fallback to copy when symlink creation is unsupported.
+    if (adapter.defaultStrategy === 'copy') {
+        return 'copy';
+    }
+    return 'symlink';
+}
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function createRemovalEntry(manifestEntry, scopeRoot) {
+    const canonicalRelative = manifestEntry.canonicalPath;
+    const name = basename(canonicalRelative);
+    return {
+        canonical: {
+            name,
+            type: manifestEntry.contentType,
+            canonicalPath: resolve(scopeRoot, canonicalRelative),
+            isFile: manifestEntry.isFile,
+        },
+        provider: manifestEntry.provider,
+        providerPath: resolve(scopeRoot, manifestEntry.providerPath),
+        operation: 'remove',
+        strategy: manifestEntry.strategy,
+        reason: 'canonical entry no longer exists',
+    };
+}
+async function classifyOperation(canonicalEntry, providerPath, strategy, renderedContent) {
+    if (strategy === 'symlink') {
+        let stat;
+        try {
+            stat = await lstat(providerPath);
+        }
+        catch (error) {
+            if (typeof error === 'object' &&
+                error !== null &&
+                'code' in error &&
+                error.code === 'ENOENT') {
+                return {
+                    operation: 'create_symlink',
+                    reason: 'provider path does not exist',
+                };
+            }
+            throw error;
+        }
+        if (!stat.isSymbolicLink()) {
+            return {
+                operation: 'update_symlink',
+                reason: 'provider path is not a symlink',
+            };
+        }
+        const linkTarget = await readlink(providerPath);
+        const resolvedTarget = resolve(dirname(providerPath), linkTarget);
+        const canonicalPath = resolve(canonicalEntry.canonicalPath);
+        const targetExists = await pathExists(resolvedTarget);
+        if (!targetExists) {
+            return {
+                operation: 'update_symlink',
+                reason: 'symlink target is missing',
+            };
+        }
+        if (resolvedTarget !== canonicalPath) {
+            return {
+                operation: 'update_symlink',
+                reason: 'symlink target differs from canonical path',
+            };
+        }
+        return {
+            operation: 'skip',
+            reason: 'already in sync',
+        };
+    }
+    const exists = await pathExists(providerPath);
+    if (!exists) {
+        return {
+            operation: 'create_copy',
+            reason: 'provider path does not exist',
+        };
+    }
+    const canonicalHash = renderedContent !== undefined
+        ? computeStringHash(renderedContent)
+        : await computeContentHash(canonicalEntry.canonicalPath, canonicalEntry.isFile);
+    const providerHash = await computeContentHash(providerPath, canonicalEntry.isFile);
+    if (canonicalHash === providerHash) {
+        return {
+            operation: 'skip',
+            reason: 'already in sync',
+        };
+    }
+    return {
+        operation: 'update_copy',
+        reason: 'copied content differs from canonical content',
+    };
+}
+function resolveScopeRoot(canonical, explicitScopeRoot) {
+    if (explicitScopeRoot) {
+        return resolve(explicitScopeRoot);
+    }
+    const firstEntry = canonical[0];
+    if (!firstEntry) {
+        return null;
+    }
+    return resolveScopeRootFromCanonical(firstEntry, canonicalRelativePath(firstEntry));
+}
+function entryContentTypeMatches(entry, contentType) {
+    return entry.type === contentType;
+}
+export async function computeSyncPlan({ canonical, adapters, manifest, scope, config, scopeRoot: explicitScopeRoot, }) {
+    const entries = [];
+    const removals = [];
+    const scopeRoot = resolveScopeRoot(canonical, explicitScopeRoot);
+    const seenCanonicalKeys = new Set();
+    const activeProviderNames = new Set();
+    for (const adapter of adapters) {
+        for (const mapping of getSyncMappings(adapter, scope)) {
+            const mappingStrategy = resolveStrategy(adapter, config, Boolean(mapping.transformCanonical));
+            if (!mappingStrategy) {
+                continue;
+            }
+            activeProviderNames.add(adapter.name);
+            for (const canonicalEntry of canonical) {
+                if (!entryContentTypeMatches(canonicalEntry, mapping.contentType)) {
+                    continue;
+                }
+                const relativeCanonicalPath = canonicalRelativePath(canonicalEntry);
+                if (!entryInsideMapping(canonicalEntry, mapping.canonicalDir)) {
+                    continue;
+                }
+                const renderedContent = mapping.transformCanonical && canonicalEntry.isFile
+                    ? mapping.transformCanonical(await readFile(canonicalEntry.canonicalPath, 'utf8'), relativeCanonicalPath.replaceAll('\\', '/'))
+                    : undefined;
+                const entryScopeRoot = scopeRoot
+                    ? scopeRoot
+                    : resolveScopeRootFromCanonical(canonicalEntry, relativeCanonicalPath);
+                const providerPath = resolve(entryScopeRoot, mapping.providerDir, providerEntryName(canonicalEntry, mapping.providerExtension));
+                const manifestEntry = findEntry(manifest, normalize(relativeCanonicalPath), adapter.name);
+                const entryStrategy = mapping.transformCanonical
+                    ? 'copy'
+                    : (manifestEntry?.strategy ?? mappingStrategy);
+                const operation = await classifyOperation(canonicalEntry, providerPath, entryStrategy, renderedContent);
+                entries.push({
+                    canonical: canonicalEntry,
+                    provider: adapter.name,
+                    providerPath,
+                    operation: operation.operation,
+                    strategy: entryStrategy,
+                    reason: operation.reason,
+                    renderedContent,
+                });
+                seenCanonicalKeys.add(`${normalize(relativeCanonicalPath)}::${adapter.name}`);
+            }
+        }
+    }
+    if (!scopeRoot) {
+        return { scope, entries, removals };
+    }
+    for (const manifestEntry of manifest.entries) {
+        if (!activeProviderNames.has(manifestEntry.provider)) {
+            continue;
+        }
+        if (scope === 'user' && manifestEntry.contentType === 'agent') {
+            continue;
+        }
+        const canonicalKey = `${normalize(manifestEntry.canonicalPath)}::${manifestEntry.provider}`;
+        if (seenCanonicalKeys.has(canonicalKey)) {
+            continue;
+        }
+        removals.push(createRemovalEntry(manifestEntry, scopeRoot));
+    }
+    return { scope, entries, removals };
+}

package/dist/engine/engine.types.d.ts

@@ -0,0 +1,28 @@
+import type { Scope } from '../shared/types.js';
+import type { CanonicalEntry } from './scanner.js';
+export type EngineScope = Exclude<Scope, 'all'>;
+export declare const SYNC_OPERATION_TYPES: readonly ["create_symlink", "create_copy", "update_symlink", "update_copy", "remove", "skip"];
+export type SyncOperationType = (typeof SYNC_OPERATION_TYPES)[number];
+export interface SyncPlanEntry {
+    canonical: CanonicalEntry;
+    provider: string;
+    providerPath: string;
+    operation: SyncOperationType;
+    strategy: 'symlink' | 'copy';
+    reason: string;
+    renderedContent?: string;
+}
+export type RemovalSyncPlanEntry = SyncPlanEntry & {
+    operation: 'remove';
+};
+export interface SyncPlan {
+    scope: EngineScope;
+    entries: SyncPlanEntry[];
+    removals: RemovalSyncPlanEntry[];
+}
+export interface SyncResult {
+    applied: number;
+    failed: number;
+    skipped: number;
+}
+//# sourceMappingURL=engine.types.d.ts.map

package/dist/engine/engine.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.types.d.ts","sourceRoot":"","sources":["../../src/engine/engine.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAEhD,eAAO,MAAM,oBAAoB,+FAOvB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtE,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,cAAc,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,iBAAiB,CAAC;IAC7B,QAAQ,EAAE,SAAS,GAAG,MAAM,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG;IAAE,SAAS,EAAE,QAAQ,CAAA;CAAE,CAAC;AAE3E,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,QAAQ,EAAE,oBAAoB,EAAE,CAAC;CAClC;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/dist/engine/engine.types.js

@@ -0,0 +1,8 @@
+export const SYNC_OPERATION_TYPES = [
+    'create_symlink',
+    'create_copy',
+    'update_symlink',
+    'update_copy',
+    'remove',
+    'skip',
+];

package/dist/engine/execute-plan.d.ts

@@ -0,0 +1,5 @@
+import type { Manifest } from '../manifest/manifest.types.js';
+import type { SyncPlan, SyncResult } from './engine.types.js';
+export declare function inferScopeRoot(canonicalPath: string): string;
+export declare function executeSyncPlan(plan: SyncPlan, manifest: Manifest, manifestPath: string): Promise<SyncResult>;
+//# sourceMappingURL=execute-plan.d.ts.map

package/dist/engine/execute-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-plan.d.ts","sourceRoot":"","sources":["../../src/engine/execute-plan.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAiB,MAAM,0BAA0B,CAAC;AAExE,OAAO,KAAK,EAAE,QAAQ,EAAiB,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAG1E,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAW5D;AAuJD,wBAAsB,eAAe,CACnC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,UAAU,CAAC,CA0BrB"}

package/dist/engine/execute-plan.js

@@ -0,0 +1,141 @@
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import { copyDirectory, copySingleFile, createSymlink } from '../fs/io.js';
+import { computeContentHash, computeStringHash } from '../manifest/hash.js';
+import { addEntry, findEntry, removeEntry, saveManifest, } from '../manifest/manager.js';
+import { insertMarker, writeDirectorySentinel } from './markers.js';
+export function inferScopeRoot(canonicalPath) {
+    const normalizedPath = canonicalPath.replaceAll('\\', '/');
+    const marker = '/.agents/';
+    const markerIndex = normalizedPath.indexOf(marker);
+    if (markerIndex === -1) {
+        throw new Error(`Cannot infer scope root from canonical path: ${canonicalPath}`);
+    }
+    return resolve(normalizedPath.slice(0, markerIndex));
+}
+function resolveManifestPaths(entry) {
+    const scopeRoot = inferScopeRoot(resolve(entry.canonical.canonicalPath));
+    return {
+        canonicalPath: relative(scopeRoot, resolve(entry.canonical.canonicalPath)),
+        providerPath: relative(scopeRoot, resolve(entry.providerPath)),
+    };
+}
+async function toManifestEntry(entry, strategy) {
+    const { canonicalPath, providerPath } = resolveManifestPaths(entry);
+    const contentHash = strategy === 'copy'
+        ? entry.renderedContent !== undefined
+            ? computeStringHash(entry.renderedContent)
+            : await computeContentHash(resolve(entry.canonical.canonicalPath), entry.canonical.isFile)
+        : null;
+    return {
+        canonicalPath,
+        providerPath,
+        provider: entry.provider,
+        contentType: entry.canonical.type,
+        strategy,
+        contentHash,
+        isFile: entry.canonical.isFile,
+        lastSynced: new Date().toISOString(),
+    };
+}
+function markerFileNameForEntry(entry) {
+    if (entry.canonical.isFile) {
+        throw new Error('Directory marker filenames are only valid for copied directory entries.');
+    }
+    // Rules are file-based, so only agent and skill directory copies reach here.
+    return entry.canonical.type === 'agent' ? 'AGENT.md' : 'SKILL.md';
+}
+async function applyCopyMarker(entry) {
+    const markerPath = join(entry.providerPath, markerFileNameForEntry(entry));
+    try {
+        await writeDirectorySentinel(entry.providerPath, entry.canonical.canonicalPath);
+        await insertMarker(markerPath, entry.canonical.canonicalPath);
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            // Marker insertion is best-effort for non-standard directory layouts.
+            return;
+        }
+        throw error;
+    }
+}
+async function applyEntry(planEntry, manifest) {
+    switch (planEntry.operation) {
+        case 'create_symlink':
+        case 'update_symlink': {
+            if (planEntry.operation === 'update_symlink') {
+                await rm(planEntry.providerPath, { recursive: true, force: true });
+            }
+            const strategyUsed = await createSymlink(planEntry.canonical.canonicalPath, planEntry.providerPath, undefined, planEntry.canonical.isFile);
+            const manifestEntry = await toManifestEntry(planEntry, strategyUsed);
+            return addEntry(manifest, manifestEntry);
+        }
+        case 'create_copy':
+        case 'update_copy': {
+            if (planEntry.operation === 'update_copy') {
+                await rm(planEntry.providerPath, { recursive: true, force: true });
+            }
+            if (planEntry.canonical.isFile &&
+                planEntry.renderedContent !== undefined) {
+                await mkdir(dirname(planEntry.providerPath), { recursive: true });
+                await writeFile(planEntry.providerPath, planEntry.renderedContent, 'utf8');
+            }
+            else if (planEntry.canonical.isFile) {
+                await copySingleFile(planEntry.canonical.canonicalPath, planEntry.providerPath);
+            }
+            else {
+                await copyDirectory(planEntry.canonical.canonicalPath, planEntry.providerPath);
+                await applyCopyMarker(planEntry);
+            }
+            const manifestEntry = await toManifestEntry(planEntry, 'copy');
+            return addEntry(manifest, manifestEntry);
+        }
+        case 'remove': {
+            await rm(planEntry.providerPath, { recursive: true, force: true });
+            const { canonicalPath } = resolveManifestPaths(planEntry);
+            return removeEntry(manifest, canonicalPath, planEntry.provider);
+        }
+        case 'skip': {
+            return manifest;
+        }
+        default:
+            return manifest;
+    }
+}
+async function ensureSkipEntryManaged(planEntry, manifest) {
+    const { canonicalPath } = resolveManifestPaths(planEntry);
+    const existing = findEntry(manifest, canonicalPath, planEntry.provider);
+    if (existing) {
+        return manifest;
+    }
+    const manifestEntry = await toManifestEntry(planEntry, planEntry.strategy);
+    return addEntry(manifest, manifestEntry);
+}
+export async function executeSyncPlan(plan, manifest, manifestPath) {
+    let nextManifest = manifest;
+    const result = {
+        applied: 0,
+        failed: 0,
+        skipped: 0,
+    };
+    const operations = [...plan.entries, ...plan.removals];
+    for (const operation of operations) {
+        if (operation.operation === 'skip') {
+            nextManifest = await ensureSkipEntryManaged(operation, nextManifest);
+            result.skipped += 1;
+            continue;
+        }
+        try {
+            nextManifest = await applyEntry(operation, nextManifest);
+            result.applied += 1;
+        }
+        catch {
+            result.failed += 1;
+        }
+    }
+    await saveManifest(manifestPath, nextManifest);
+    return result;
+}

package/dist/engine/hook.d.ts

@@ -0,0 +1,23 @@
+export declare const HOOK_MARKER_START = "# >>> oat pre-commit hook >>>";
+export declare const HOOK_MARKER_END = "# <<< oat pre-commit hook <<<";
+export declare const HOOK_DRIFT_WARNING = "oat: project provider views are out of sync - run 'oat status --scope project' or 'oat sync --scope project'";
+export declare const REPO_GITHOOKS_PATH = ".githooks";
+export interface HookInstallInfo {
+    hookPath: string;
+    suggestedHooksPath: string | null;
+    suggestedHookPath: string | null;
+}
+interface RunHookCheckOptions {
+    runStatusCommand?: (cwd: string) => Promise<boolean>;
+    warn?: (message: string) => void;
+}
+export declare function getHookInstallInfo(projectRoot: string): Promise<HookInstallInfo>;
+export declare function configureLocalHooksPath(projectRoot: string, hooksPath: string): Promise<void>;
+export declare function isHookInstalled(projectRoot: string): Promise<boolean>;
+export declare function installHook(projectRoot: string): Promise<string>;
+export declare function uninstallHook(projectRoot: string): Promise<void>;
+export declare function runHookCheck(cwd: string, options?: RunHookCheckOptions): Promise<{
+    inSync: boolean;
+}>;
+export {};
+//# sourceMappingURL=hook.d.ts.map

package/dist/engine/hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../src/engine/hook.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,iBAAiB,kCAAkC,CAAC;AACjE,eAAO,MAAM,eAAe,kCAAkC,CAAC;AAC/D,eAAO,MAAM,kBAAkB,iHACiF,CAAC;AACjH,eAAO,MAAM,kBAAkB,cAAc,CAAC;AAE9C,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED,UAAU,mBAAmB;IAC3B,gBAAgB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACrD,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC;AAwHD,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,eAAe,CAAC,CA4B1B;AAED,wBAAsB,uBAAuB,CAC3C,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,wBAAsB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAgB3E;AAED,wBAAsB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAgCtE;AAuBD,wBAAsB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoCtE;AAWD,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,CAAC,CAsB9B"}