@open-agent-toolkit/cli 0.0.10

package/dist/config/oat-config.js

@@ -0,0 +1,319 @@
+import { execSync } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { atomicWriteJson, dirExists, fileExists } from '../fs/io.js';
+import { normalizeToPosixPath } from '../fs/paths.js';
+const DEFAULT_OAT_CONFIG = { version: 1 };
+const DEFAULT_OAT_LOCAL_CONFIG = { version: 1 };
+const DEFAULT_USER_CONFIG = { version: 1 };
+function getConfigPath(repoRoot) {
+    return join(repoRoot, '.oat', 'config.json');
+}
+function getLocalConfigPath(repoRoot) {
+    return join(repoRoot, '.oat', 'config.local.json');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isMissingFileError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}
+function trimPathValue(value) {
+    return value.replace(/\/+$/, '').replace(/^\.\//, '').trim();
+}
+function normalizeProjectPath(repoRoot, pathValue) {
+    if (pathValue == null) {
+        return null;
+    }
+    const trimmed = pathValue.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (!isAbsolute(trimmed)) {
+        const normalizedRelative = trimPathValue(normalizeToPosixPath(trimmed));
+        return normalizedRelative && normalizedRelative !== '.'
+            ? normalizedRelative
+            : null;
+    }
+    const repoRootResolved = resolve(repoRoot);
+    const absoluteResolved = resolve(trimmed);
+    const isInsideRepo = absoluteResolved === repoRootResolved ||
+        absoluteResolved.startsWith(`${repoRootResolved}${sep}`);
+    if (!isInsideRepo) {
+        return null;
+    }
+    const relativePath = normalizeToPosixPath(relative(repoRootResolved, absoluteResolved));
+    const normalizedRelative = trimPathValue(relativePath);
+    return normalizedRelative && normalizedRelative !== '.'
+        ? normalizedRelative
+        : null;
+}
+function normalizeOatConfig(parsed) {
+    const next = { ...DEFAULT_OAT_CONFIG };
+    if (!isRecord(parsed)) {
+        return next;
+    }
+    if (isRecord(parsed.worktrees) &&
+        typeof parsed.worktrees.root === 'string' &&
+        parsed.worktrees.root.trim()) {
+        next.worktrees = { root: parsed.worktrees.root.trim() };
+    }
+    if (isRecord(parsed.projects) &&
+        typeof parsed.projects.root === 'string' &&
+        parsed.projects.root.trim()) {
+        next.projects = { root: parsed.projects.root.trim() };
+    }
+    if (isRecord(parsed.git)) {
+        const git = {};
+        if (typeof parsed.git.defaultBranch === 'string' &&
+            parsed.git.defaultBranch.trim()) {
+            git.defaultBranch = parsed.git.defaultBranch.trim();
+        }
+        if (Object.keys(git).length > 0) {
+            next.git = git;
+        }
+    }
+    if (isRecord(parsed.archive)) {
+        const archive = {};
+        if (typeof parsed.archive.s3Uri === 'string' &&
+            parsed.archive.s3Uri.trim()) {
+            archive.s3Uri = parsed.archive.s3Uri.trim().replace(/\/+$/, '');
+        }
+        if (typeof parsed.archive.s3SyncOnComplete === 'boolean') {
+            archive.s3SyncOnComplete = parsed.archive.s3SyncOnComplete;
+        }
+        if (typeof parsed.archive.summaryExportPath === 'string' &&
+            parsed.archive.summaryExportPath.trim()) {
+            archive.summaryExportPath = normalizeToPosixPath(parsed.archive.summaryExportPath.trim().replace(/\/+$/, ''));
+        }
+        if (Object.keys(archive).length > 0) {
+            next.archive = archive;
+        }
+    }
+    if (isRecord(parsed.documentation)) {
+        const doc = {};
+        if (typeof parsed.documentation.root === 'string' &&
+            parsed.documentation.root.trim()) {
+            doc.root = parsed.documentation.root.trim();
+        }
+        if (typeof parsed.documentation.tooling === 'string' &&
+            parsed.documentation.tooling.trim()) {
+            doc.tooling = parsed.documentation.tooling.trim();
+        }
+        if (typeof parsed.documentation.config === 'string' &&
+            parsed.documentation.config.trim()) {
+            doc.config = parsed.documentation.config.trim();
+        }
+        if (typeof parsed.documentation.index === 'string' &&
+            parsed.documentation.index.trim()) {
+            doc.index = parsed.documentation.index.trim();
+        }
+        if (typeof parsed.documentation.requireForProjectCompletion === 'boolean') {
+            doc.requireForProjectCompletion =
+                parsed.documentation.requireForProjectCompletion;
+        }
+        if (Object.keys(doc).length > 0) {
+            next.documentation = doc;
+        }
+    }
+    if (Array.isArray(parsed.localPaths)) {
+        const filtered = parsed.localPaths.filter((v) => typeof v === 'string' && v.trim() !== '');
+        if (filtered.length > 0) {
+            next.localPaths = [...new Set(filtered)].sort();
+        }
+    }
+    if (typeof parsed.autoReviewAtCheckpoints === 'boolean') {
+        next.autoReviewAtCheckpoints = parsed.autoReviewAtCheckpoints;
+    }
+    return next;
+}
+function normalizeOatLocalConfig(repoRoot, parsed) {
+    const next = { ...DEFAULT_OAT_LOCAL_CONFIG };
+    if (!isRecord(parsed)) {
+        return next;
+    }
+    if ('activeProject' in parsed) {
+        const rawValue = typeof parsed.activeProject === 'string' || parsed.activeProject === null
+            ? parsed.activeProject
+            : null;
+        next.activeProject = normalizeProjectPath(repoRoot, rawValue);
+    }
+    if ('lastPausedProject' in parsed) {
+        const rawValue = typeof parsed.lastPausedProject === 'string' ||
+            parsed.lastPausedProject === null
+            ? parsed.lastPausedProject
+            : null;
+        next.lastPausedProject = normalizeProjectPath(repoRoot, rawValue);
+    }
+    if ('activeIdea' in parsed) {
+        next.activeIdea =
+            typeof parsed.activeIdea === 'string' && parsed.activeIdea.trim()
+                ? parsed.activeIdea.trim()
+                : null;
+    }
+    return next;
+}
+export function resolveLocalPaths(config) {
+    return config.localPaths ?? [];
+}
+export async function readOatConfig(repoRoot) {
+    const configPath = getConfigPath(repoRoot);
+    try {
+        const raw = await readFile(configPath, 'utf8');
+        return normalizeOatConfig(JSON.parse(raw));
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return { ...DEFAULT_OAT_CONFIG };
+        }
+        throw error;
+    }
+}
+export async function readOatLocalConfig(repoRoot) {
+    const configPath = getLocalConfigPath(repoRoot);
+    try {
+        const raw = await readFile(configPath, 'utf8');
+        return normalizeOatLocalConfig(repoRoot, JSON.parse(raw));
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return { ...DEFAULT_OAT_LOCAL_CONFIG };
+        }
+        throw error;
+    }
+}
+export async function writeOatConfig(repoRoot, config) {
+    const configPath = getConfigPath(repoRoot);
+    const normalized = normalizeOatConfig(config);
+    await atomicWriteJson(configPath, normalized);
+}
+export async function writeOatLocalConfig(repoRoot, config) {
+    const configPath = getLocalConfigPath(repoRoot);
+    const normalized = normalizeOatLocalConfig(repoRoot, config);
+    await atomicWriteJson(configPath, normalized);
+}
+export async function resolveActiveProject(repoRoot) {
+    const localConfig = await readOatLocalConfig(repoRoot);
+    const projectPath = localConfig.activeProject ?? null;
+    if (!projectPath) {
+        return { name: null, path: null, status: 'unset' };
+    }
+    const absoluteProjectPath = join(repoRoot, projectPath);
+    const statePath = join(absoluteProjectPath, 'state.md');
+    const isValid = (await dirExists(absoluteProjectPath)) && (await fileExists(statePath));
+    return {
+        name: basename(absoluteProjectPath),
+        path: projectPath,
+        status: isValid ? 'active' : 'missing',
+    };
+}
+export async function setActiveProject(repoRoot, projectRelativePath) {
+    const normalizedPath = normalizeProjectPath(repoRoot, projectRelativePath);
+    if (!normalizedPath) {
+        throw new Error(`Active project path must be repo-relative or inside repo root: ${projectRelativePath}`);
+    }
+    const localConfig = await readOatLocalConfig(repoRoot);
+    await writeOatLocalConfig(repoRoot, {
+        ...localConfig,
+        activeProject: normalizedPath,
+    });
+}
+export async function clearActiveProject(repoRoot, options) {
+    const localConfig = await readOatLocalConfig(repoRoot);
+    const lastPaused = options?.lastPaused === undefined
+        ? localConfig.lastPausedProject
+        : normalizeProjectPath(repoRoot, options.lastPaused);
+    await writeOatLocalConfig(repoRoot, {
+        ...localConfig,
+        activeProject: null,
+        lastPausedProject: lastPaused,
+    });
+}
+function getUserConfigPath(userConfigDir) {
+    return join(userConfigDir, 'config.json');
+}
+function normalizeUserConfig(parsed) {
+    const next = { ...DEFAULT_USER_CONFIG };
+    if (!isRecord(parsed)) {
+        return next;
+    }
+    if ('activeIdea' in parsed) {
+        next.activeIdea =
+            typeof parsed.activeIdea === 'string' && parsed.activeIdea.trim()
+                ? parsed.activeIdea.trim()
+                : null;
+    }
+    return next;
+}
+export async function readUserConfig(userConfigDir) {
+    const configPath = getUserConfigPath(userConfigDir);
+    try {
+        const raw = await readFile(configPath, 'utf8');
+        return normalizeUserConfig(JSON.parse(raw));
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return { ...DEFAULT_USER_CONFIG };
+        }
+        throw error;
+    }
+}
+export async function writeUserConfig(userConfigDir, config) {
+    const configPath = getUserConfigPath(userConfigDir);
+    const normalized = normalizeUserConfig(config);
+    await atomicWriteJson(configPath, normalized);
+}
+export async function resolveActiveIdea(repoRoot, userConfigDir) {
+    const localConfig = await readOatLocalConfig(repoRoot);
+    if (localConfig.activeIdea) {
+        return localConfig.activeIdea;
+    }
+    const userConfig = await readUserConfig(userConfigDir);
+    return userConfig.activeIdea ?? null;
+}
+export async function setActiveIdea(repoRoot, ideaPath) {
+    const localConfig = await readOatLocalConfig(repoRoot);
+    await writeOatLocalConfig(repoRoot, {
+        ...localConfig,
+        activeIdea: ideaPath.trim(),
+    });
+}
+export async function clearActiveIdea(repoRoot) {
+    const localConfig = await readOatLocalConfig(repoRoot);
+    await writeOatLocalConfig(repoRoot, {
+        ...localConfig,
+        activeIdea: null,
+    });
+}
+export function detectDefaultBranch(repoRoot) {
+    try {
+        const branch = execSync('gh repo view --json defaultBranchRef --jq .defaultBranchRef.name', {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            timeout: 10_000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        if (branch)
+            return branch;
+    }
+    catch {
+        // gh not available or not authenticated — fall through
+    }
+    try {
+        const ref = execSync('git rev-parse --abbrev-ref origin/HEAD', {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            timeout: 5_000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        if (ref.startsWith('origin/'))
+            return ref.replace('origin/', '');
+    }
+    catch {
+        // origin/HEAD not set — fall through
+    }
+    return 'main';
+}

package/dist/config/runtime.d.ts

@@ -0,0 +1,2 @@
+export declare function isInteractive(json: boolean): boolean;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/config/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/config/runtime.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAEpD"}

package/dist/config/runtime.js

@@ -0,0 +1,3 @@
+export function isInteractive(json) {
+    return Boolean(process.stdin.isTTY) && !json;
+}

package/dist/config/sync-config.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+declare const ProviderConfigSchema: z.ZodObject<{
+    strategy: z.ZodOptional<z.ZodEnum<["symlink", "copy", "auto"]>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    strategy?: "symlink" | "copy" | "auto" | undefined;
+    enabled?: boolean | undefined;
+}, {
+    strategy?: "symlink" | "copy" | "auto" | undefined;
+    enabled?: boolean | undefined;
+}>;
+export declare const SyncConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    defaultStrategy: z.ZodEnum<["symlink", "copy", "auto"]>;
+    providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        strategy: z.ZodOptional<z.ZodEnum<["symlink", "copy", "auto"]>>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        strategy?: "symlink" | "copy" | "auto" | undefined;
+        enabled?: boolean | undefined;
+    }, {
+        strategy?: "symlink" | "copy" | "auto" | undefined;
+        enabled?: boolean | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    defaultStrategy: "symlink" | "copy" | "auto";
+    providers?: Record<string, {
+        strategy?: "symlink" | "copy" | "auto" | undefined;
+        enabled?: boolean | undefined;
+    }> | undefined;
+}, {
+    version: 1;
+    defaultStrategy: "symlink" | "copy" | "auto";
+    providers?: Record<string, {
+        strategy?: "symlink" | "copy" | "auto" | undefined;
+        enabled?: boolean | undefined;
+    }> | undefined;
+}>;
+export type ProviderSyncConfig = z.infer<typeof ProviderConfigSchema>;
+export type SyncConfig = z.infer<typeof SyncConfigSchema> & {
+    providers: Record<string, ProviderSyncConfig>;
+};
+export declare const DEFAULT_SYNC_CONFIG: SyncConfig;
+export declare function loadSyncConfig(configPath: string, defaults?: SyncConfig): Promise<SyncConfig>;
+export declare function saveSyncConfig(configPath: string, config: SyncConfig): Promise<SyncConfig>;
+export declare function setProviderEnabled(configPath: string, providerName: string, enabled: boolean): Promise<SyncConfig>;
+export {};
+//# sourceMappingURL=sync-config.d.ts.map

package/dist/config/sync-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-config.d.ts","sourceRoot":"","sources":["../../src/config/sync-config.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,oBAAoB;;;;;;;;;EAGxB,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI3B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEtE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,GAAG;IAC1D,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;CAC/C,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,UAIjC,CAAC;AAoDF,wBAAsB,cAAc,CAClC,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,UAAgC,GACzC,OAAO,CAAC,UAAU,CAAC,CA4BrB;AAED,wBAAsB,cAAc,CAClC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,UAAU,GACjB,OAAO,CAAC,UAAU,CAAC,CAWrB;AAED,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,UAAU,CAAC,CAcrB"}

package/dist/config/sync-config.js

@@ -0,0 +1,94 @@
+import { readFile } from 'node:fs/promises';
+import { CliError } from '../errors/index.js';
+import { atomicWriteJson } from '../fs/io.js';
+import { SyncStrategySchema } from '../shared/types.js';
+import { z } from 'zod';
+const ProviderConfigSchema = z.object({
+    strategy: SyncStrategySchema.optional(),
+    enabled: z.boolean().optional(),
+});
+export const SyncConfigSchema = z.object({
+    version: z.literal(1),
+    defaultStrategy: SyncStrategySchema,
+    providers: z.record(ProviderConfigSchema).optional(),
+});
+export const DEFAULT_SYNC_CONFIG = {
+    version: 1,
+    defaultStrategy: 'auto',
+    providers: {},
+};
+function mergeProviderConfigs(base, override) {
+    const merged = { ...base };
+    for (const [name, config] of Object.entries(override)) {
+        merged[name] = {
+            ...(merged[name] ?? {}),
+            ...config,
+        };
+    }
+    return merged;
+}
+function normalizeConfig(config, defaults) {
+    return {
+        version: 1,
+        defaultStrategy: config.defaultStrategy ?? defaults.defaultStrategy,
+        providers: mergeProviderConfigs(defaults.providers, config.providers ?? {}),
+    };
+}
+function parseSyncConfig(raw, configPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new CliError(`Sync config at ${configPath} is not valid JSON. Fix the file and retry.`);
+    }
+    const result = SyncConfigSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new CliError(`Sync config at ${configPath} failed validation. Fix the file and retry.`);
+    }
+    return result.data;
+}
+export async function loadSyncConfig(configPath, defaults = DEFAULT_SYNC_CONFIG) {
+    try {
+        const raw = await readFile(configPath, 'utf8');
+        return normalizeConfig(parseSyncConfig(raw, configPath), defaults);
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return {
+                ...defaults,
+                providers: { ...defaults.providers },
+            };
+        }
+        if (error instanceof CliError) {
+            throw error;
+        }
+        throw new CliError(`Unable to load sync config from ${configPath}: ${error instanceof Error ? error.message : 'unknown error'}`, 2);
+    }
+}
+export async function saveSyncConfig(configPath, config) {
+    const result = SyncConfigSchema.safeParse(config);
+    if (!result.success) {
+        throw new CliError(`Sync config at ${configPath} failed validation. Fix the config object and retry.`);
+    }
+    const normalized = normalizeConfig(result.data, DEFAULT_SYNC_CONFIG);
+    await atomicWriteJson(configPath, normalized);
+    return normalized;
+}
+export async function setProviderEnabled(configPath, providerName, enabled) {
+    const current = await loadSyncConfig(configPath, DEFAULT_SYNC_CONFIG);
+    const next = {
+        ...current,
+        providers: {
+            ...current.providers,
+            [providerName]: {
+                ...(current.providers[providerName] ?? {}),
+                enabled,
+            },
+        },
+    };
+    return saveSyncConfig(configPath, next);
+}

package/dist/drift/detector.d.ts

@@ -0,0 +1,4 @@
+import type { ManifestEntry } from '../manifest/manifest.types.js';
+import type { DriftReport } from './drift.types.js';
+export declare function detectDrift(entry: ManifestEntry, scopeRoot: string): Promise<DriftReport>;
+//# sourceMappingURL=detector.d.ts.map

package/dist/drift/detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../../src/drift/detector.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAcjD,wBAAsB,WAAW,CAC/B,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,WAAW,CAAC,CAmEtB"}

package/dist/drift/detector.js

@@ -0,0 +1,69 @@
+import { lstat, readlink, stat } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { computeContentHash } from '../manifest/hash.js';
+function createReport(entry, state) {
+    return {
+        canonical: entry.canonicalPath,
+        provider: entry.provider,
+        providerPath: entry.providerPath,
+        state,
+    };
+}
+export async function detectDrift(entry, scopeRoot) {
+    const providerPath = resolve(scopeRoot, entry.providerPath);
+    const canonicalPath = resolve(scopeRoot, entry.canonicalPath);
+    // Missing check must run first, before strategy-specific branches.
+    let providerStat;
+    try {
+        providerStat = await lstat(providerPath);
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return createReport(entry, { status: 'missing' });
+        }
+        throw error;
+    }
+    if (entry.strategy === 'symlink') {
+        if (!providerStat.isSymbolicLink()) {
+            return createReport(entry, {
+                status: 'drifted',
+                reason: 'replaced',
+            });
+        }
+        const linkTarget = await readlink(providerPath);
+        const resolvedTarget = resolve(dirname(providerPath), linkTarget);
+        try {
+            await stat(resolvedTarget);
+        }
+        catch (error) {
+            if (typeof error === 'object' &&
+                error !== null &&
+                'code' in error &&
+                error.code === 'ENOENT') {
+                return createReport(entry, {
+                    status: 'drifted',
+                    reason: 'broken',
+                });
+            }
+            throw error;
+        }
+        if (resolvedTarget !== canonicalPath) {
+            return createReport(entry, {
+                status: 'drifted',
+                reason: 'replaced',
+            });
+        }
+        return createReport(entry, { status: 'in_sync' });
+    }
+    const currentHash = await computeContentHash(providerPath, entry.isFile);
+    if (entry.contentHash === currentHash) {
+        return createReport(entry, { status: 'in_sync' });
+    }
+    return createReport(entry, {
+        status: 'drifted',
+        reason: 'modified',
+    });
+}

package/dist/drift/drift.types.d.ts

@@ -0,0 +1,17 @@
+export type DriftState = {
+    status: 'in_sync';
+} | {
+    status: 'drifted';
+    reason: 'modified' | 'broken' | 'replaced';
+} | {
+    status: 'missing';
+} | {
+    status: 'stray';
+};
+export interface DriftReport {
+    canonical: string | null;
+    provider: string;
+    providerPath: string;
+    state: DriftState;
+}
+//# sourceMappingURL=drift.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drift.types.d.ts","sourceRoot":"","sources":["../../src/drift/drift.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAClB;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,UAAU,GAAG,QAAQ,GAAG,UAAU,CAAA;CAAE,GACjE;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,CAAC;AAExB,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,UAAU,CAAC;CACnB"}

package/dist/drift/drift.types.js

@@ -0,0 +1 @@
+export {};

package/dist/drift/index.d.ts

@@ -0,0 +1,4 @@
+export { detectDrift } from './detector.js';
+export type { DriftReport, DriftState } from './drift.types.js';
+export { detectStrays } from './strays.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/drift/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC"}

package/dist/drift/index.js

@@ -0,0 +1,2 @@
+export { detectDrift } from './detector.js';
+export { detectStrays } from './strays.js';

package/dist/drift/strays.d.ts

@@ -0,0 +1,7 @@
+import type { CanonicalEntry } from '../engine/scanner.js';
+import type { Manifest } from '../manifest/manifest.types.js';
+import type { PathMapping } from '../providers/shared/adapter.types.js';
+import type { DriftReport } from './drift.types.js';
+export declare function inferScopeRoot(providerDir: string): string;
+export declare function detectStrays(provider: string, providerDir: string, manifest: Manifest, canonicalEntries: CanonicalEntry[], mapping?: Pick<PathMapping, 'contentType' | 'providerExtension'>): Promise<DriftReport[]>;
+//# sourceMappingURL=strays.d.ts.map

package/dist/drift/strays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strays.d.ts","sourceRoot":"","sources":["../../src/drift/strays.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAGnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAgBjD,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAoHD,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,QAAQ,EAClB,gBAAgB,EAAE,cAAc,EAAE,EAClC,OAAO,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,aAAa,GAAG,mBAAmB,CAAC,GAC/D,OAAO,CAAC,WAAW,EAAE,CAAC,CAsDxB"}