@open-agent-toolkit/cli 0.0.10

package/dist/engine/hook.js

@@ -0,0 +1,254 @@
+import { execFile } from 'node:child_process';
+import { chmod, lstat, readFile, readlink, rm, writeFile, } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { ensureDir } from '../fs/io.js';
+const execFileAsync = promisify(execFile);
+export const HOOK_MARKER_START = '# >>> oat pre-commit hook >>>';
+export const HOOK_MARKER_END = '# <<< oat pre-commit hook <<<';
+export const HOOK_DRIFT_WARNING = "oat: project provider views are out of sync - run 'oat status --scope project' or 'oat sync --scope project'";
+export const REPO_GITHOOKS_PATH = '.githooks';
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function createHookSnippet(options = {}) {
+    const lines = [
+        HOOK_MARKER_START,
+        'if command -v oat >/dev/null 2>&1; then',
+        '  if ! oat status --scope project >/dev/null 2>&1; then',
+        `    echo "${HOOK_DRIFT_WARNING}" >&2`,
+        '  fi',
+        'fi',
+        HOOK_MARKER_END,
+    ];
+    if (!options.includeShebang) {
+        return lines.join('\n');
+    }
+    return ['#!/bin/sh', '', ...lines].join('\n');
+}
+async function resolveGitDirectory(projectRoot) {
+    const gitPath = join(projectRoot, '.git');
+    try {
+        const gitStat = await lstat(gitPath);
+        if (gitStat.isSymbolicLink()) {
+            const symlinkTarget = await readlink(gitPath);
+            return resolve(dirname(gitPath), symlinkTarget);
+        }
+        if (gitStat.isFile()) {
+            const content = await readFile(gitPath, 'utf8');
+            const match = /^gitdir:\s*(.+)$/m.exec(content.trim());
+            if (match?.[1]) {
+                return resolve(projectRoot, match[1].trim());
+            }
+        }
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return gitPath;
+        }
+        throw error;
+    }
+    return gitPath;
+}
+async function resolveConfiguredHooksPath(projectRoot) {
+    try {
+        const { stdout } = await execFileAsync('git', ['config', '--get', 'core.hooksPath'], { cwd: projectRoot });
+        const configured = stdout.trim();
+        if (configured) {
+            return resolve(projectRoot, configured);
+        }
+    }
+    catch {
+        // Not set or git not available — fall through to default resolution.
+    }
+    return null;
+}
+async function resolveHooksDirectory(projectRoot, options = {}) {
+    const shouldCreate = options.createIfMissing ?? false;
+    const configuredPath = await resolveConfiguredHooksPath(projectRoot);
+    if (configuredPath) {
+        if (shouldCreate) {
+            await ensureDir(configuredPath);
+        }
+        return configuredPath;
+    }
+    const gitDir = await resolveGitDirectory(projectRoot);
+    const hooksDir = join(gitDir, 'hooks');
+    try {
+        const hooksStat = await lstat(hooksDir);
+        if (!hooksStat.isSymbolicLink()) {
+            return hooksDir;
+        }
+        const symlinkTarget = await readlink(hooksDir);
+        const resolvedTarget = resolve(dirname(hooksDir), symlinkTarget);
+        if (shouldCreate) {
+            await ensureDir(resolvedTarget);
+        }
+        return resolvedTarget;
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            if (shouldCreate) {
+                await ensureDir(hooksDir);
+            }
+            return hooksDir;
+        }
+        throw error;
+    }
+}
+export async function getHookInstallInfo(projectRoot) {
+    const hooksDir = await resolveHooksDirectory(projectRoot);
+    const hookPath = join(hooksDir, 'pre-commit');
+    const suggestedHookPath = join(projectRoot, REPO_GITHOOKS_PATH, 'pre-commit');
+    let suggestedHooksPath = null;
+    if (!(await resolveConfiguredHooksPath(projectRoot))) {
+        try {
+            await lstat(suggestedHookPath);
+            suggestedHooksPath = REPO_GITHOOKS_PATH;
+        }
+        catch (error) {
+            if (typeof error === 'object' &&
+                error !== null &&
+                'code' in error &&
+                error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+    return {
+        hookPath,
+        suggestedHooksPath,
+        suggestedHookPath: suggestedHooksPath ? suggestedHookPath : null,
+    };
+}
+export async function configureLocalHooksPath(projectRoot, hooksPath) {
+    await execFileAsync('git', ['config', '--local', 'core.hooksPath', hooksPath], {
+        cwd: projectRoot,
+    });
+}
+export async function isHookInstalled(projectRoot) {
+    const { hookPath } = await getHookInstallInfo(projectRoot);
+    try {
+        const content = await readFile(hookPath, 'utf8');
+        return content.includes(HOOK_MARKER_START);
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+export async function installHook(projectRoot) {
+    const hookPath = (await getHookInstallInfo(projectRoot)).hookPath;
+    let current = '';
+    try {
+        current = await readFile(hookPath, 'utf8');
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    if (current.includes(HOOK_MARKER_START)) {
+        await chmod(hookPath, 0o755);
+        return hookPath;
+    }
+    const includeShebang = current.trim().length === 0;
+    const snippet = createHookSnippet({ includeShebang });
+    await ensureDir(dirname(hookPath));
+    const next = current.trim().length > 0
+        ? `${current.trimEnd()}\n\n${snippet}\n`
+        : `${snippet}\n`;
+    await writeFile(hookPath, next, 'utf8');
+    await chmod(hookPath, 0o755);
+    return hookPath;
+}
+function removeHookSnippet(content) {
+    const markerStart = escapeRegExp(HOOK_MARKER_START);
+    const markerEnd = escapeRegExp(HOOK_MARKER_END);
+    const normalized = content.replaceAll('\r\n', '\n');
+    const wholeSnippetPattern = new RegExp(`^#!/bin/sh\\n\\n${markerStart}[\\s\\S]*?${markerEnd}\\n?$`);
+    if (wholeSnippetPattern.test(normalized)) {
+        return '';
+    }
+    const markerBlockPattern = new RegExp(`\\n?${markerStart}[\\s\\S]*?${markerEnd}\\n?`, 'm');
+    const withoutMarker = normalized.replace(markerBlockPattern, '\n');
+    const compacted = withoutMarker.replace(/\n{3,}/g, '\n\n').trimEnd();
+    return compacted.length > 0 ? `${compacted}\n` : '';
+}
+export async function uninstallHook(projectRoot) {
+    const hooksDir = await resolveHooksDirectory(projectRoot);
+    const hookPath = join(hooksDir, 'pre-commit');
+    let current = '';
+    try {
+        current = await readFile(hookPath, 'utf8');
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return;
+        }
+        throw error;
+    }
+    if (!current.includes(HOOK_MARKER_START)) {
+        return;
+    }
+    const next = removeHookSnippet(current);
+    if (next.trim().length === 0) {
+        const hookStat = await lstat(hookPath);
+        if (hookStat.isSymbolicLink()) {
+            // Preserve the symlink — write empty content through it instead of
+            // deleting the link itself (which would break managed hook setups).
+            await writeFile(hookPath, '', 'utf8');
+        }
+        else {
+            await rm(hookPath, { force: true });
+        }
+        return;
+    }
+    await writeFile(hookPath, next, 'utf8');
+}
+async function runStatusCommandDefault(cwd) {
+    try {
+        await execFileAsync('oat', ['status', '--scope', 'project'], { cwd });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runHookCheck(cwd, options = {}) {
+    const runStatusCommand = options.runStatusCommand ?? runStatusCommandDefault;
+    const warn = options.warn ??
+        ((message) => {
+            process.stderr.write(`${message}\n`);
+        });
+    let inSync = false;
+    try {
+        // Default impl already returns boolean on failures, but this catch
+        // protects custom injected implementations from escaping exceptions.
+        inSync = await runStatusCommand(cwd);
+    }
+    catch {
+        inSync = false;
+    }
+    if (!inSync) {
+        warn(HOOK_DRIFT_WARNING);
+    }
+    return { inSync };
+}

package/dist/engine/index.d.ts

@@ -0,0 +1,9 @@
+export { computeSyncPlan } from './compute-plan.js';
+export { type EngineScope, type RemovalSyncPlanEntry, SYNC_OPERATION_TYPES, type SyncOperationType, type SyncPlan, type SyncPlanEntry, type SyncResult, } from './engine.types.js';
+export { executeSyncPlan } from './execute-plan.js';
+export { configureLocalHooksPath, getHookInstallInfo, HOOK_DRIFT_WARNING, HOOK_MARKER_END, HOOK_MARKER_START, installHook, isHookInstalled, REPO_GITHOOKS_PATH, runHookCheck, uninstallHook, } from './hook.js';
+export type { HookInstallInfo } from './hook.js';
+export { hasMarker, insertMarker, OAT_DIRECTORY_SENTINEL, OAT_MARKER_PREFIX, writeDirectorySentinel, } from './markers.js';
+export type { CanonicalEntry } from './scanner.js';
+export { scanCanonical } from './scanner.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/engine/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,oBAAoB,EACpB,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,UAAU,GAChB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EACL,uBAAuB,EACvB,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,YAAY,EACZ,aAAa,GACd,MAAM,QAAQ,CAAC;AAChB,YAAY,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EACL,SAAS,EACT,YAAY,EACZ,sBAAsB,EACtB,iBAAiB,EACjB,sBAAsB,GACvB,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC"}

package/dist/engine/index.js

@@ -0,0 +1,6 @@
+export { computeSyncPlan } from './compute-plan.js';
+export { SYNC_OPERATION_TYPES, } from './engine.types.js';
+export { executeSyncPlan } from './execute-plan.js';
+export { configureLocalHooksPath, getHookInstallInfo, HOOK_DRIFT_WARNING, HOOK_MARKER_END, HOOK_MARKER_START, installHook, isHookInstalled, REPO_GITHOOKS_PATH, runHookCheck, uninstallHook, } from './hook.js';
+export { hasMarker, insertMarker, OAT_DIRECTORY_SENTINEL, OAT_MARKER_PREFIX, writeDirectorySentinel, } from './markers.js';
+export { scanCanonical } from './scanner.js';

package/dist/engine/markers.d.ts

@@ -0,0 +1,6 @@
+export declare const OAT_MARKER_PREFIX = "<!-- OAT-managed: do not edit directly.";
+export declare const OAT_DIRECTORY_SENTINEL = ".oat-generated";
+export declare function hasMarker(filePath: string): Promise<boolean>;
+export declare function insertMarker(filePath: string, canonicalPath: string): Promise<void>;
+export declare function writeDirectorySentinel(directoryPath: string, canonicalPath: string): Promise<void>;
+//# sourceMappingURL=markers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"markers.d.ts","sourceRoot":"","sources":["../../src/engine/markers.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,4CAA4C,CAAC;AAC3E,eAAO,MAAM,sBAAsB,mBAAmB,CAAC;AAMvD,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGlE;AAED,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,wBAAsB,sBAAsB,CAC1C,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CAIf"}

package/dist/engine/markers.js

@@ -0,0 +1,24 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export const OAT_MARKER_PREFIX = '<!-- OAT-managed: do not edit directly.';
+export const OAT_DIRECTORY_SENTINEL = '.oat-generated';
+function buildMarkerLine(canonicalPath) {
+    return `${OAT_MARKER_PREFIX} Source: ${canonicalPath} -->`;
+}
+export async function hasMarker(filePath) {
+    const contents = await readFile(filePath, 'utf8');
+    return contents.startsWith(OAT_MARKER_PREFIX);
+}
+export async function insertMarker(filePath, canonicalPath) {
+    const contents = await readFile(filePath, 'utf8');
+    if (contents.startsWith(OAT_MARKER_PREFIX)) {
+        return;
+    }
+    const marker = buildMarkerLine(canonicalPath);
+    await writeFile(filePath, `${marker}\n${contents}`, 'utf8');
+}
+export async function writeDirectorySentinel(directoryPath, canonicalPath) {
+    const sentinelPath = join(directoryPath, OAT_DIRECTORY_SENTINEL);
+    const marker = buildMarkerLine(canonicalPath);
+    await writeFile(sentinelPath, `${marker}\n`, 'utf8');
+}

package/dist/engine/scanner.d.ts

@@ -0,0 +1,11 @@
+import { type Scope } from '../shared/types.js';
+type ConcreteScope = Exclude<Scope, 'all'>;
+export interface CanonicalEntry {
+    name: string;
+    type: 'skill' | 'agent' | 'rule';
+    canonicalPath: string;
+    isFile: boolean;
+}
+export declare function scanCanonical(basePath: string, scope: ConcreteScope): Promise<CanonicalEntry[]>;
+export {};
+//# sourceMappingURL=scanner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scanner.d.ts","sourceRoot":"","sources":["../../src/engine/scanner.ts"],"names":[],"mappings":"AAIA,OAAO,EAAuB,KAAK,KAAK,EAAE,MAAM,eAAe,CAAC;AAEhE,KAAK,aAAa,GAAG,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAE3C,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,OAAO,CAAC;CACjB;AA0DD,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,aAAa,GACnB,OAAO,CAAC,cAAc,EAAE,CAAC,CA2B3B"}

package/dist/engine/scanner.js

@@ -0,0 +1,65 @@
+import { readdir } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { CliError } from '../errors/index.js';
+import { SCOPE_CONTENT_TYPES } from '../shared/types.js';
+function canonicalDirectoryName(contentType) {
+    if (contentType === 'skill') {
+        return 'skills';
+    }
+    if (contentType === 'agent') {
+        return 'agents';
+    }
+    return 'rules';
+}
+async function readEntries(dirPath) {
+    try {
+        const entries = await readdir(dirPath, { withFileTypes: true });
+        const results = [];
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                results.push({ name: entry.name, isFile: false });
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                results.push({ name: entry.name, isFile: true });
+            }
+        }
+        results.sort((left, right) => left.name.localeCompare(right.name));
+        return results;
+    }
+    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 canonical directory ${dirPath}. Adjust permissions and retry.`);
+        }
+        throw error;
+    }
+}
+export async function scanCanonical(basePath, scope) {
+    const scopeRoot = resolve(basePath);
+    const entries = [];
+    for (const contentType of SCOPE_CONTENT_TYPES[scope]) {
+        const contentDir = join(scopeRoot, '.agents', canonicalDirectoryName(contentType));
+        const includeFiles = contentType === 'agent' || contentType === 'rule';
+        const scanned = await readEntries(contentDir);
+        for (const scannedEntry of scanned) {
+            if (scannedEntry.isFile && !includeFiles) {
+                continue;
+            }
+            entries.push({
+                name: scannedEntry.name,
+                type: contentType,
+                canonicalPath: join(contentDir, scannedEntry.name),
+                isFile: scannedEntry.isFile,
+            });
+        }
+    }
+    return entries;
+}

package/dist/engine/test-helpers.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderAdapter } from '../providers/shared/adapter.types.js';
+export declare function createTestAdapter(overrides?: Partial<ProviderAdapter>): ProviderAdapter;
+//# sourceMappingURL=test-helpers.d.ts.map

package/dist/engine/test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../src/engine/test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEvE,wBAAgB,iBAAiB,CAC/B,SAAS,GAAE,OAAO,CAAC,eAAe,CAAM,GACvC,eAAe,CA8BjB"}

package/dist/engine/test-helpers.js

@@ -0,0 +1,31 @@
+export function createTestAdapter(overrides = {}) {
+    return {
+        name: 'claude',
+        displayName: 'Claude Code',
+        defaultStrategy: 'symlink',
+        projectMappings: [
+            {
+                contentType: 'skill',
+                canonicalDir: '.agents/skills',
+                providerDir: '.claude/skills',
+                nativeRead: false,
+            },
+            {
+                contentType: 'agent',
+                canonicalDir: '.agents/agents',
+                providerDir: '.claude/agents',
+                nativeRead: false,
+            },
+        ],
+        userMappings: [
+            {
+                contentType: 'skill',
+                canonicalDir: '.agents/skills',
+                providerDir: '.claude/skills',
+                nativeRead: false,
+            },
+        ],
+        detect: async () => true,
+        ...overrides,
+    };
+}

package/dist/errors/cli-error.d.ts

@@ -0,0 +1,5 @@
+export declare class CliError extends Error {
+    readonly exitCode: 1 | 2;
+    constructor(message: string, exitCode?: 1 | 2);
+}
+//# sourceMappingURL=cli-error.d.ts.map

package/dist/errors/cli-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-error.d.ts","sourceRoot":"","sources":["../../src/errors/cli-error.ts"],"names":[],"mappings":"AAAA,qBAAa,QAAS,SAAQ,KAAK;aAGf,QAAQ,EAAE,CAAC,GAAG,CAAC;gBAD/B,OAAO,EAAE,MAAM,EACC,QAAQ,GAAE,CAAC,GAAG,CAAK;CAKtC"}

package/dist/errors/cli-error.js

@@ -0,0 +1,8 @@
+export class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = 'CliError';
+    }
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { CliError } from './cli-error.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC"}

package/dist/errors/index.js

@@ -0,0 +1 @@
+export { CliError } from './cli-error.js';

package/dist/fs/assets.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveAssetsRoot(): Promise<string>;
+//# sourceMappingURL=assets.d.ts.map

package/dist/fs/assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../src/fs/assets.ts"],"names":[],"mappings":"AAMA,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC,CAsBzD"}

package/dist/fs/assets.js

@@ -0,0 +1,22 @@
+import { stat } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { CliError } from '../errors/index.js';
+export async function resolveAssetsRoot() {
+    const modulePath = fileURLToPath(import.meta.url);
+    const cliRoot = resolve(dirname(modulePath), '..', '..');
+    const assetsRoot = join(cliRoot, 'assets');
+    try {
+        const assetsStat = await stat(assetsRoot);
+        if (!assetsStat.isDirectory()) {
+            throw new CliError(`Assets path is not a directory: ${assetsRoot}`, 2);
+        }
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            throw error;
+        }
+        throw new CliError(`Assets directory not found: ${assetsRoot}. Run 'pnpm build' to generate bundled assets.`, 2);
+    }
+    return assetsRoot;
+}

package/dist/fs/index.d.ts

@@ -0,0 +1,4 @@
+export { resolveAssetsRoot } from './assets.js';
+export { atomicWriteJson, copyDirectory, copySingleFile, createSymlink, dirExists, ensureDir, fileExists, } from './io.js';
+export { normalizeToPosixPath, resolveProjectRoot, resolveScopeRoot, toPosixPath, validatePathWithinScope, } from './paths.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/fs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fs/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EACL,eAAe,EACf,aAAa,EACb,cAAc,EACd,aAAa,EACb,SAAS,EACT,SAAS,EACT,UAAU,GACX,MAAM,MAAM,CAAC;AACd,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,gBAAgB,EAChB,WAAW,EACX,uBAAuB,GACxB,MAAM,SAAS,CAAC"}

package/dist/fs/index.js

@@ -0,0 +1,3 @@
+export { resolveAssetsRoot } from './assets.js';
+export { atomicWriteJson, copyDirectory, copySingleFile, createSymlink, dirExists, ensureDir, fileExists, } from './io.js';
+export { normalizeToPosixPath, resolveProjectRoot, resolveScopeRoot, toPosixPath, validatePathWithinScope, } from './paths.js';

package/dist/fs/io.d.ts

@@ -0,0 +1,9 @@
+export declare function fileExists(path: string): Promise<boolean>;
+export declare function dirExists(path: string): Promise<boolean>;
+export type LinkStrategy = 'symlink' | 'copy';
+export declare function ensureDir(dirPath: string): Promise<void>;
+export declare function copyDirectory(src: string, dest: string): Promise<void>;
+export declare function copySingleFile(src: string, dest: string): Promise<void>;
+export declare function createSymlink(target: string, linkPath: string, onFallback?: (error: unknown) => void, isFile?: boolean): Promise<LinkStrategy>;
+export declare function atomicWriteJson(filePath: string, data: unknown): Promise<void>;
+//# sourceMappingURL=io.d.ts.map

package/dist/fs/io.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"io.d.ts","sourceRoot":"","sources":["../../src/fs/io.ts"],"names":[],"mappings":"AAYA,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO/D;AAED,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO9D;AAED,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,MAAM,CAAC;AAE9C,wBAAsB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE9D;AAED,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkB5E;AAED,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI7E;AAED,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,EACrC,MAAM,CAAC,EAAE,OAAO,GACf,OAAO,CAAC,YAAY,CAAC,CAuBvB;AAED,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,IAAI,CAAC,CAKf"}

package/dist/fs/io.js

@@ -0,0 +1,74 @@
+import { mkdir, readdir, readFile, rename, rm, stat, symlink, writeFile, } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative } from 'node:path';
+export async function fileExists(path) {
+    try {
+        const s = await stat(path);
+        return s.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export async function dirExists(path) {
+    try {
+        const s = await stat(path);
+        return s.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureDir(dirPath) {
+    await mkdir(dirPath, { recursive: true });
+}
+export async function copyDirectory(src, dest) {
+    await ensureDir(dest);
+    const entries = await readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const sourcePath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirectory(sourcePath, destPath);
+            continue;
+        }
+        if (entry.isFile()) {
+            const content = await readFile(sourcePath);
+            await writeFile(destPath, content);
+        }
+    }
+}
+export async function copySingleFile(src, dest) {
+    await ensureDir(dirname(dest));
+    const content = await readFile(src);
+    await writeFile(dest, content);
+}
+export async function createSymlink(target, linkPath, onFallback, isFile) {
+    await ensureDir(dirname(linkPath));
+    // Use relative symlink targets so links stay valid when the source tree
+    // moves (e.g., git worktrees that are later deleted). The original absolute
+    // path is preserved for the copy fallback below.
+    const symlinkTarget = isAbsolute(target)
+        ? relative(dirname(linkPath), target)
+        : target;
+    try {
+        await symlink(symlinkTarget, linkPath, isFile ? 'file' : 'dir');
+        return 'symlink';
+    }
+    catch (error) {
+        onFallback?.(error);
+        await rm(linkPath, { recursive: true, force: true });
+        if (isFile) {
+            await copySingleFile(target, linkPath);
+        }
+        else {
+            await copyDirectory(target, linkPath);
+        }
+        return 'copy';
+    }
+}
+export async function atomicWriteJson(filePath, data) {
+    const tempPath = `${filePath}.tmp`;
+    await ensureDir(dirname(filePath));
+    await writeFile(tempPath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+    await rename(tempPath, filePath);
+}

package/dist/fs/paths.d.ts

@@ -0,0 +1,9 @@
+import type { Scope } from '../shared/types.js';
+type ConcreteScope = Exclude<Scope, 'all'>;
+export declare function resolveProjectRoot(cwd: string): Promise<string>;
+export declare function resolveScopeRoot(scope: ConcreteScope, cwd: string, home: string): string;
+export declare function toPosixPath(pathValue: string): string;
+export declare function normalizeToPosixPath(pathValue: string): string;
+export declare function validatePathWithinScope(candidatePath: string, scopeRoot: string): string;
+export {};
+//# sourceMappingURL=paths.d.ts.map

package/dist/fs/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/fs/paths.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,KAAK,aAAa,GAAG,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAE3C,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAiBrE;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GACX,MAAM,CAMR;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,GAChB,MAAM,CAcR"}

package/dist/fs/paths.js

@@ -0,0 +1,42 @@
+import { access } from 'node:fs/promises';
+import { dirname, posix, resolve, sep } from 'node:path';
+import { CliError } from '../errors/index.js';
+export async function resolveProjectRoot(cwd) {
+    let current = resolve(cwd);
+    while (true) {
+        try {
+            await access(resolve(current, '.git'));
+            return current;
+        }
+        catch {
+            const parent = dirname(current);
+            if (parent === current) {
+                break;
+            }
+            current = parent;
+        }
+    }
+    throw new CliError(`Unable to resolve project root from ${cwd}`, 2);
+}
+export function resolveScopeRoot(scope, cwd, home) {
+    if (scope === 'user') {
+        return resolve(home);
+    }
+    return resolve(cwd);
+}
+export function toPosixPath(pathValue) {
+    return pathValue.replaceAll('\\', '/');
+}
+export function normalizeToPosixPath(pathValue) {
+    return posix.normalize(toPosixPath(pathValue));
+}
+export function validatePathWithinScope(candidatePath, scopeRoot) {
+    const resolvedScopeRoot = resolve(scopeRoot);
+    const resolvedCandidatePath = resolve(candidatePath);
+    const isInside = resolvedCandidatePath === resolvedScopeRoot ||
+        resolvedCandidatePath.startsWith(`${resolvedScopeRoot}${sep}`);
+    if (!isInside) {
+        throw new CliError(`Path ${candidatePath} is outside scope root ${scopeRoot}`);
+    }
+    return resolvedCandidatePath;
+}