@open-agent-toolkit/cli 0.2.40 → 0.2.45

package/dist/commands/project/pull/index.js

@@ -0,0 +1,157 @@
+import { buildCommandContext, } from '../../../app/command-context.js';
+import { defaultGitRunner } from '../../project/sync/git.js';
+import { abortSynced as defaultAbortSynced, commitRecordChange as defaultCommitRecordChange, continueSynced as defaultContinueSynced, pullChildren as defaultPullChildren, pullSynced as defaultPullSynced, } from '../../project/sync/ref-sync.js';
+import { resolveSyncedTarget, } from '../../project/sync/resolve-target.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { CliError } from '../../../errors/cli-error.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { Command } from 'commander';
+const DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    resolveProjectRoot,
+    resolveSyncedTarget,
+    pullSynced: defaultPullSynced,
+    pullChildren: defaultPullChildren,
+    commitRecordChange: defaultCommitRecordChange,
+    continueSynced: defaultContinueSynced,
+    abortSynced: defaultAbortSynced,
+    gitRunner: defaultGitRunner,
+    processEnv: process.env,
+};
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function reportPullResult(context, result, target, targetArg, children = []) {
+    const payload = {
+        ...result,
+        adopted: result.adopted ?? false,
+        ref: target.ref,
+        children,
+    };
+    if (context.json) {
+        context.logger.json(payload);
+    }
+    else if (result.status === 'created' ||
+        result.status === 'updated' ||
+        result.status === 'up-to-date') {
+        context.logger.info(`Pull ${result.status}: ${target.slug} at ${result.sha}.`);
+    }
+    else if (result.status === 'conflict') {
+        context.logger.error(`Pull ${result.status}${result.conflicts?.length ? ` (${result.conflicts.join(', ')})` : ''}. Resolve the files, then run oat project pull ${shellQuote(targetArg)} --continue; or run oat project pull ${shellQuote(targetArg)} --abort.`);
+    }
+    else {
+        context.logger.error(`Pull dirty. Commit and publish with oat project push ${shellQuote(targetArg)}, or explicitly stash/clean the synced checkout before retrying oat project pull ${shellQuote(targetArg)}.`);
+    }
+    if (!context.json) {
+        for (const child of children) {
+            if (child.status !== 'missing' &&
+                child.status !== 'error' &&
+                child.status !== 'conflict' &&
+                child.status !== 'dirty') {
+                continue;
+            }
+            const childArg = shellQuote(child.slug);
+            const diagnostic = child.message ??
+                (child.conflicts?.length
+                    ? `conflicts: ${child.conflicts.join(', ')}`
+                    : 'no diagnostic provided');
+            const retry = child.status === 'conflict'
+                ? `Resolve its files, then run oat project pull ${childArg} --continue; or oat project pull ${childArg} --abort.`
+                : child.status === 'dirty'
+                    ? `Run oat project push ${childArg}, or explicitly stash/clean it before retrying oat project pull ${childArg}.`
+                    : child.status === 'error'
+                        ? `Repair the reported Git/system failure, then retry oat project pull ${childArg}.`
+                        : `Retry with oat project pull ${childArg}.`;
+            context.logger.error(`Child ${child.slug} ${child.status}: ${diagnostic}. ${retry}`);
+        }
+    }
+    const childExitCode = children.reduce((highest, child) => {
+        const current = child.exitCode ??
+            (child.status === 'error'
+                ? 2
+                : child.status === 'missing' ||
+                    child.status === 'conflict' ||
+                    child.status === 'dirty'
+                    ? 1
+                    : 0);
+        return current > highest ? current : highest;
+    }, 0);
+    process.exitCode =
+        result.status === 'created' ||
+            result.status === 'updated' ||
+            result.status === 'up-to-date'
+            ? childExitCode
+            : 1;
+}
+async function runPull(context, pathOrSlug, options, dependencies) {
+    try {
+        if (options.continue && options.abort) {
+            throw new CliError('`--continue` and `--abort` are mutually exclusive.', 1);
+        }
+        const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+        const target = await dependencies.resolveSyncedTarget({ repoRoot, env: dependencies.processEnv }, pathOrSlug, {}, { allowMissingCheckout: !options.continue && !options.abort });
+        const targetArg = pathOrSlug ?? target.projectPath;
+        if (options.abort) {
+            await dependencies.abortSynced(target, dependencies.gitRunner);
+            if (context.json) {
+                context.logger.json({ status: 'aborted', ref: target.ref });
+            }
+            else {
+                context.logger.info(`Aborted pull recovery for ${target.slug}.`);
+            }
+            process.exitCode = 0;
+            return;
+        }
+        const result = options.continue
+            ? await dependencies.continueSynced(target, dependencies.gitRunner, {
+                adopt: target.adoptionRecord !== 'durable',
+                adoptionRecord: target.adoptionRecord,
+            })
+            : await dependencies.pullSynced(target, dependencies.gitRunner, {
+                adopt: target.adopt,
+                adoptionRecord: target.adoptionRecord,
+            });
+        const successful = result.status === 'created' ||
+            result.status === 'updated' ||
+            result.status === 'up-to-date';
+        const children = successful && options.children !== false
+            ? await dependencies.pullChildren(target, dependencies.gitRunner)
+            : [];
+        const pendingRecordPaths = [
+            ...(result.pendingRecordPaths ?? []),
+            ...children.flatMap((child) => child.pendingRecordPaths ?? []),
+        ];
+        if (options.commit !== false && pendingRecordPaths.length > 0) {
+            const slugs = [
+                ...(result.adopted ? [target.slug] : []),
+                ...children.filter((child) => child.adopted).map((child) => child.slug),
+            ];
+            await dependencies.commitRecordChange(repoRoot, pendingRecordPaths, `chore(oat): adopt synced project${slugs.length === 1 ? '' : 's'} ${slugs.join(', ')}`, dependencies.gitRunner, { projectRoots: target });
+        }
+        reportPullResult(context, result, target, targetArg, children);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (context.json) {
+            context.logger.json({ status: 'error', message });
+        }
+        else {
+            context.logger.error(message);
+        }
+        process.exitCode = error instanceof CliError ? error.exitCode : 2;
+    }
+}
+export function createProjectPullCommand(overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    return new Command('pull')
+        .description('Materialize or update a synced OAT project')
+        .argument('[project-path|slug]', 'Synced project path or slug')
+        .option('--continue', 'Continue a resolved sync rebase')
+        .option('--abort', 'Abort an in-progress sync rebase')
+        .option('--no-children', 'Do not pull coordination child projects')
+        .option('--no-commit', 'Leave adopted discovery records uncommitted')
+        .action(async (pathOrSlug, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runPull(context, pathOrSlug, options, dependencies);
+    });
+}

package/dist/commands/project/push/index.d.ts

@@ -0,0 +1,22 @@
+import { readFile } from 'node:fs/promises';
+import { type CommandContext, type GlobalOptions } from '../../../app/command-context.js';
+import { refreshPrLinks } from '../../project/links/refresh.js';
+import { type GitRunner } from '../../project/sync/git.js';
+import { type PushResult, type SyncTarget } from '../../project/sync/ref-sync.js';
+import { resolveSyncedTarget } from '../../project/sync/resolve-target.js';
+import { Command } from 'commander';
+interface ProjectPushDependencies {
+    buildCommandContext: (options: GlobalOptions) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    resolveSyncedTarget: typeof resolveSyncedTarget;
+    pushSynced: (target: SyncTarget, git: GitRunner, options: {
+        message?: string;
+    }) => Promise<PushResult>;
+    gitRunner: GitRunner;
+    processEnv: NodeJS.ProcessEnv;
+    refreshPrLinks: typeof refreshPrLinks;
+    readFile: typeof readFile;
+}
+export declare function createProjectPushCommand(overrides?: Partial<ProjectPushDependencies>): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/project/push/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/push/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,UAAU,EAChB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAQ5E,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC,UAAU,uBAAuB;IAC/B,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,mBAAmB,EAAE,OAAO,mBAAmB,CAAC;IAChD,UAAU,EAAE,CACV,MAAM,EAAE,UAAU,EAClB,GAAG,EAAE,SAAS,EACd,OAAO,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAC1B,OAAO,CAAC,UAAU,CAAC,CAAC;IACzB,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;IAC9B,cAAc,EAAE,OAAO,cAAc,CAAC;IACtC,QAAQ,EAAE,OAAO,QAAQ,CAAC;CAC3B;AAqGD,wBAAgB,wBAAwB,CACtC,SAAS,GAAE,OAAO,CAAC,uBAAuB,CAAM,GAC/C,OAAO,CAmBT"}

package/dist/commands/project/push/index.js

@@ -0,0 +1,100 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { buildCommandContext, } from '../../../app/command-context.js';
+import { refreshPrLinks } from '../../project/links/refresh.js';
+import { defaultGitRunner } from '../../project/sync/git.js';
+import { pushSynced as defaultPushSynced, } from '../../project/sync/ref-sync.js';
+import { resolveSyncedTarget } from '../../project/sync/resolve-target.js';
+import { getFrontmatterBlock, parseFrontmatterScalarFields, } from '../../shared/frontmatter.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { CliError } from '../../../errors/cli-error.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { Command } from 'commander';
+const DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    resolveProjectRoot,
+    resolveSyncedTarget,
+    pushSynced: defaultPushSynced,
+    gitRunner: defaultGitRunner,
+    processEnv: process.env,
+    refreshPrLinks,
+    readFile,
+};
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+async function runPush(context, pathOrSlug, options, dependencies) {
+    try {
+        const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+        const target = await dependencies.resolveSyncedTarget({ repoRoot, env: dependencies.processEnv }, pathOrSlug);
+        const result = await dependencies.pushSynced(target, dependencies.gitRunner, { message: options.message });
+        let prRefresh;
+        if (options.refreshPr &&
+            (result.status === 'pushed' || result.status === 'up-to-date')) {
+            const state = await dependencies
+                .readFile(join(target.projectPath, 'state.md'), 'utf8')
+                .catch(() => null);
+            const frontmatter = state ? getFrontmatterBlock(state) : null;
+            if (frontmatter) {
+                const parsed = parseFrontmatterScalarFields(frontmatter, [
+                    'oat_pr_status',
+                    'oat_pr_url',
+                ]);
+                if (parsed.valid &&
+                    parsed.values.oat_pr_status === 'open' &&
+                    parsed.values.oat_pr_url) {
+                    try {
+                        prRefresh = await dependencies.refreshPrLinks(target, parsed.values.oat_pr_url, { warn: (message) => context.logger.warn(message) });
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        context.logger.warn(`Could not refresh PR links after successfully pushing ${target.slug}: ${message}`);
+                        prRefresh = 'failed';
+                    }
+                }
+            }
+        }
+        const payload = { ...result, ref: target.ref, prRefresh };
+        if (context.json) {
+            context.logger.json(payload);
+        }
+        else if (result.status === 'pushed') {
+            context.logger.info(`Pushed ${target.slug} at ${result.sha}.`);
+        }
+        else if (result.status === 'up-to-date') {
+            context.logger.info(`${target.slug} is up to date at ${result.sha}.`);
+        }
+        else if (result.status === 'conflict') {
+            const targetArg = pathOrSlug ?? target.projectPath;
+            context.logger.error(`Push conflict${result.conflicts?.length ? ` (${result.conflicts.join(', ')})` : ''}. Resolve the files, then run oat project pull ${shellQuote(targetArg)} --continue; or run oat project pull ${shellQuote(targetArg)} --abort.`);
+        }
+        else {
+            const targetArg = pathOrSlug ?? target.projectPath;
+            context.logger.error(`Push rejected. Run oat project pull ${shellQuote(targetArg)}, then run oat project push ${shellQuote(targetArg)}.`);
+        }
+        process.exitCode =
+            result.status === 'pushed' || result.status === 'up-to-date' ? 0 : 1;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (context.json) {
+            context.logger.json({ status: 'error', message });
+        }
+        else {
+            context.logger.error(message);
+        }
+        process.exitCode = error instanceof CliError ? error.exitCode : 2;
+    }
+}
+export function createProjectPushCommand(overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    return new Command('push')
+        .description('Commit and publish a synced OAT project')
+        .argument('[project-path|slug]', 'Synced project path or slug')
+        .option('--message <message>', 'Artifact commit message')
+        .option('--no-refresh-pr', 'Do not refresh PR artifact links')
+        .action(async (pathOrSlug, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runPush(context, pathOrSlug, options, dependencies);
+    });
+}

package/dist/commands/project/scope/index.d.ts

@@ -0,0 +1,17 @@
+import { type CommandContext, type GlobalOptions } from '../../../app/command-context.js';
+import { readSyncedRecord } from '../../project/sync/record.js';
+import { isSyncedCheckout } from '../../shared/project-scope.js';
+import { type OatLocalConfig } from '../../../config/oat-config.js';
+import { Command } from 'commander';
+interface ProjectScopeDependencies {
+    buildCommandContext: (options: GlobalOptions) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    resolveProjectsRoot: (repoRoot: string, env: NodeJS.ProcessEnv) => Promise<string>;
+    readOatLocalConfig: (repoRoot: string) => Promise<OatLocalConfig>;
+    readSyncedRecord: typeof readSyncedRecord;
+    isSyncedCheckout: typeof isSyncedCheckout;
+    processEnv: NodeJS.ProcessEnv;
+}
+export declare function createProjectScopeCommand(overrides?: Partial<ProjectScopeDependencies>): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/project/scope/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/scope/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEjE,OAAO,EAEL,gBAAgB,EAKjB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAG7E,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AAM5C,UAAU,wBAAwB;IAChC,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,CAAC,UAAU,KACnB,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IAClE,gBAAgB,EAAE,OAAO,gBAAgB,CAAC;IAC1C,gBAAgB,EAAE,OAAO,gBAAgB,CAAC;IAC1C,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;CAC/B;AAoHD,wBAAgB,yBAAyB,CACvC,SAAS,GAAE,OAAO,CAAC,wBAAwB,CAAM,GAChD,OAAO,CAuBT"}

package/dist/commands/project/scope/index.js

@@ -0,0 +1,107 @@
+import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { buildCommandContext, } from '../../../app/command-context.js';
+import { readSyncedRecord } from '../../project/sync/record.js';
+import { resolveProjectsRoot } from '../../shared/oat-paths.js';
+import { canonicalizePath, isSyncedCheckout, resolveProjectScope, resolveProjectsParent, resolveScopeRoot, syncedRecordPath, } from '../../shared/project-scope.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { readOatLocalConfig } from '../../../config/oat-config.js';
+import { CliError } from '../../../errors/cli-error.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { Command, Option } from 'commander';
+const DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    resolveProjectRoot,
+    resolveProjectsRoot,
+    readOatLocalConfig,
+    readSyncedRecord,
+    isSyncedCheckout,
+    processEnv: process.env,
+};
+function isWithin(root, candidate) {
+    const child = relative(root, candidate);
+    return (child === '' ||
+        (child !== '..' && !child.startsWith(`..${sep}`) && !isAbsolute(child)));
+}
+async function runProjectScope(context, pathArg, options, dependencies) {
+    try {
+        const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+        const projectsRoot = await dependencies.resolveProjectsRoot(repoRoot, dependencies.processEnv);
+        const canonicalRepoRoot = canonicalizePath(repoRoot);
+        const configuredRoot = canonicalizePath(isAbsolute(projectsRoot)
+            ? resolve(projectsRoot)
+            : resolve(repoRoot, projectsRoot));
+        const configuredParent = resolveProjectsParent(repoRoot, projectsRoot);
+        const archivedRoot = join(configuredParent, 'archived');
+        let target = pathArg;
+        if (!target) {
+            target =
+                (await dependencies.readOatLocalConfig(repoRoot)).activeProject ??
+                    undefined;
+            if (!target) {
+                throw new CliError('No active project is configured.', 1);
+            }
+        }
+        const absoluteProjectPath = canonicalizePath(isAbsolute(target) ? resolve(target) : resolve(repoRoot, target));
+        if (isWithin(archivedRoot, absoluteProjectPath)) {
+            throw new CliError('Archived projects have no active project scope. Restore or open a live project instead.', 1);
+        }
+        const scope = resolveProjectScope(absoluteProjectPath, configuredRoot, repoRoot);
+        if (!scope) {
+            throw new CliError(`Project path is outside the shared, local, and synced scope roots: ${target}`, 1);
+        }
+        const projectPath = relative(canonicalRepoRoot, absoluteProjectPath)
+            .split(sep)
+            .join('/');
+        const payload = {
+            status: 'ok',
+            projectPath,
+            scope,
+            checkout: 'n/a',
+        };
+        if (scope === 'synced') {
+            const slug = basename(absoluteProjectPath);
+            const scopeRoot = resolveScopeRoot(repoRoot, projectsRoot, 'synced');
+            const record = await dependencies.readSyncedRecord(syncedRecordPath(scopeRoot, slug));
+            payload['ref'] = record?.ref;
+            payload['record'] = record ?? undefined;
+            payload['checkout'] = (await dependencies.isSyncedCheckout(absoluteProjectPath))
+                ? 'present'
+                : 'absent';
+        }
+        if (options.format === 'value') {
+            context.logger.info(scope);
+        }
+        else if (context.json || options.format === 'json') {
+            context.logger.json(payload);
+        }
+        else {
+            context.logger.info(`Project: ${projectPath}`);
+            context.logger.info(`Scope: ${scope}`);
+        }
+        process.exitCode = 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (context.json || options.format === 'json') {
+            context.logger.json({ status: 'error', message });
+        }
+        else {
+            context.logger.error(message);
+        }
+        process.exitCode = error instanceof CliError ? error.exitCode : 2;
+    }
+}
+export function createProjectScopeCommand(overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    return new Command('scope')
+        .description('Report the scope of an OAT project')
+        .argument('[project-path]', 'Project path; defaults to activeProject')
+        .addOption(new Option('--format <format>', 'Output format').choices([
+        'json',
+        'value',
+    ]))
+        .action(async (projectPath, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runProjectScope(context, projectPath, options, dependencies);
+    });
+}

package/dist/commands/project/split/run.d.ts

@@ -1,5 +1,7 @@
 import { appendFile, readFile, readdir, stat } from 'node:fs/promises';
 import { type CommandContext, type GlobalOptions } from '../../../app/command-context.js';
+import { type GitRunner } from '../../project/sync/git.js';
+import { pushSynced as defaultPushSynced } from '../../project/sync/ref-sync.js';
 import { confirmAction } from '../../shared/shared.prompts.js';
 import { Command } from 'commander';
 interface RunSplitDependencies {
@@ -15,6 +17,8 @@ interface RunSplitDependencies {
     }) => Promise<void>;
     confirmAction: typeof confirmAction;
     processEnv: NodeJS.ProcessEnv;
+    gitRunner: GitRunner;
+    pushSynced: typeof defaultPushSynced;
 }
 export declare function createProjectSplitRunCommand(overrides?: Partial<RunSplitDependencies>): Command;
 export {};

package/dist/commands/project/split/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/split/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAGvE,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAKhE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqBpC,UAAU,oBAAoB;IAC5B,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,CAAC,UAAU,KACnB,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAC1B,OAAO,EAAE,OAAO,OAAO,CAAC;IACxB,IAAI,EAAE,OAAO,IAAI,CAAC;IAClB,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,gBAAgB,EAAE,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACnE,aAAa,EAAE,OAAO,aAAa,CAAC;IACpC,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;CAC/B;AAsLD,wBAAgB,4BAA4B,CAC1C,SAAS,GAAE,OAAO,CAAC,oBAAoB,CAAM,GAC5C,OAAO,CAgKT"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/split/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAGvE,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EAAE,UAAU,IAAI,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAOlF,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAMhE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqBpC,UAAU,oBAAoB;IAC5B,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,CAAC,UAAU,KACnB,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAC1B,OAAO,EAAE,OAAO,OAAO,CAAC;IACxB,IAAI,EAAE,OAAO,IAAI,CAAC;IAClB,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,gBAAgB,EAAE,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACnE,aAAa,EAAE,OAAO,aAAa,CAAC;IACpC,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;IAC9B,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,OAAO,iBAAiB,CAAC;CACtC;AAiND,wBAAgB,4BAA4B,CAC1C,SAAS,GAAE,OAAO,CAAC,oBAAoB,CAAM,GAC5C,OAAO,CAkLT"}

package/dist/commands/project/split/run.js

@@ -1,11 +1,15 @@
 import { appendFile, readFile, readdir, stat } from 'node:fs/promises';
 import { isAbsolute, join, relative } from 'node:path';
 import { buildCommandContext, } from '../../../app/command-context.js';
+import { defaultGitRunner } from '../../project/sync/git.js';
+import { pushSynced as defaultPushSynced } from '../../project/sync/ref-sync.js';
 import { resolveProjectsRoot } from '../../shared/oat-paths.js';
+import { resolveProjectScope, resolveScopeRoot, } from '../../shared/project-scope.js';
 import { confirmAction } from '../../shared/shared.prompts.js';
 import { readGlobalOptions } from '../../shared/shared.utils.js';
 import { generateStateDashboard } from '../../state/generate.js';
 import { readOatLocalConfig } from '../../../config/oat-config.js';
+import { CliError } from '../../../errors/cli-error.js';
 import { resolveProjectRoot } from '../../../fs/paths.js';
 import { Command } from 'commander';
 import { validateSplitPlanDocumentShape } from '../../../projects/split/document-validation.js';
@@ -27,6 +31,8 @@ const DEFAULT_DEPENDENCIES = {
     },
     confirmAction,
     processEnv: process.env,
+    gitRunner: defaultGitRunner,
+    pushSynced: defaultPushSynced,
 };
 async function exists(path, dependencies) {
     try {
@@ -122,13 +128,33 @@ async function runFreshSplit(document, repoRoot, projectsRoot, dependencies, opt
     }
     const validation = validateChildPlan(document.plan, slugs);
     if (!validation.ok) {
-        throw new Error(`Split plan validation failed: ${validation.errors
+        throw new CliError(`Split plan validation failed: ${validation.errors
             .map((error) => error.message)
-            .join('; ')}`);
+            .join('; ')}`, 1);
     }
-    await writeCoordinationParent(document, { repoRoot, projectsRoot });
-    await seedChildren(document.plan, { repoRoot, projectsRoot });
-    await finalizeSplit(document.plan, { repoRoot, projectsRoot });
+    const localConfig = await readOatLocalConfig(repoRoot);
+    const scope = localConfig.activeProject
+        ? resolveProjectScope(localConfig.activeProject, projectsRoot, repoRoot)
+        : null;
+    const inheritedScope = scope ?? 'shared';
+    const absoluteScopeRoot = inheritedScope === 'shared'
+        ? isAbsolute(projectsRoot)
+            ? projectsRoot
+            : join(repoRoot, projectsRoot)
+        : resolveScopeRoot(repoRoot, projectsRoot, inheritedScope);
+    const scopeRoot = toRepoRelativeProjectPath(repoRoot, absoluteScopeRoot);
+    const splitContext = {
+        repoRoot,
+        projectsRoot,
+        scope: inheritedScope,
+        scopeRoot,
+        env: dependencies.processEnv,
+        gitRunner: dependencies.gitRunner,
+        pushSynced: dependencies.pushSynced,
+    };
+    await writeCoordinationParent(document, splitContext);
+    await seedChildren(document.plan, splitContext);
+    await finalizeSplit(document.plan, splitContext);
 }
 export function createProjectSplitRunCommand(overrides = {}) {
     const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
@@ -146,9 +172,9 @@ export function createProjectSplitRunCommand(overrides = {}) {
             const parsed = JSON.parse(raw);
             const documentShape = validateSplitPlanDocumentShape(parsed);
             if (!documentShape.ok) {
-                throw new Error(`Invalid SplitPlanDocument: ${documentShape.errors
+                throw new CliError(`Invalid SplitPlanDocument: ${documentShape.errors
                     .map((error) => error.message)
-                    .join('; ')}`);
+                    .join('; ')}`, 1);
             }
             const document = documentShape.document;
             if (isEffectivelyNonInteractive(options, context, dependencies.processEnv) &&
@@ -159,7 +185,14 @@ export function createProjectSplitRunCommand(overrides = {}) {
                 process.exitCode = 1;
                 return;
             }
-            const parentPath = join(projectsRoot, document.plan.parentSlug)
+            const localConfig = await readOatLocalConfig(repoRoot);
+            const activeScope = localConfig.activeProject
+                ? resolveProjectScope(localConfig.activeProject, projectsRoot, repoRoot)
+                : null;
+            const parentRoot = activeScope && activeScope !== 'shared'
+                ? resolveScopeRoot(repoRoot, projectsRoot, activeScope)
+                : projectsRoot;
+            const parentPath = join(parentRoot, document.plan.parentSlug)
                 .split('\\')
                 .join('/');
             const absoluteParentPath = isAbsolute(parentPath)
@@ -216,7 +249,12 @@ export function createProjectSplitRunCommand(overrides = {}) {
                         throw new SplitResumeError('Split resume cancelled.');
                     }
                 }
-                await continueSplitResume(partial, { repoRoot, projectsRoot });
+                await continueSplitResume(partial, {
+                    repoRoot,
+                    projectsRoot,
+                    gitRunner: dependencies.gitRunner,
+                    pushSynced: dependencies.pushSynced,
+                });
             }
             else {
                 await runFreshSplit(document, repoRoot, projectsRoot, dependencies);
@@ -239,7 +277,7 @@ export function createProjectSplitRunCommand(overrides = {}) {
                 process.exitCode = 1;
                 return;
             }
-            process.exitCode = 1;
+            process.exitCode = error instanceof CliError ? error.exitCode : 2;
         }
     });
 }

package/dist/commands/project/sync/git.d.ts

@@ -0,0 +1,18 @@
+import { type ExecFileException, type ExecFileOptionsWithStringEncoding } from 'node:child_process';
+export interface GitResult {
+    stdout: string;
+    stderr: string;
+    code: number;
+}
+export interface GitRunOptions {
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    allowFailure?: boolean;
+}
+export interface GitRunner {
+    run(args: string[], options: GitRunOptions): Promise<GitResult>;
+}
+export type ExecFileImplementation = (file: string, args: readonly string[], options: ExecFileOptionsWithStringEncoding, callback: (error: ExecFileException | null, stdout: string, stderr: string) => void) => unknown;
+export declare function createGitRunner(execFileImpl?: ExecFileImplementation): GitRunner;
+export declare const defaultGitRunner: GitRunner;
+//# sourceMappingURL=git.d.ts.map

package/dist/commands/project/sync/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/sync/git.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,iCAAiC,EACvC,MAAM,oBAAoB,CAAC;AAI5B,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,SAAS;IACxB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;CACjE;AAED,MAAM,MAAM,sBAAsB,GAAG,CACnC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,iCAAiC,EAC1C,QAAQ,EAAE,CACR,KAAK,EAAE,iBAAiB,GAAG,IAAI,EAC/B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,KACX,IAAI,KACN,OAAO,CAAC;AAqCb,wBAAgB,eAAe,CAC7B,YAAY,GAAE,sBAAiC,GAC9C,SAAS,CAqCX;AAED,eAAO,MAAM,gBAAgB,WAAoB,CAAC"}

package/dist/commands/project/sync/git.js

@@ -0,0 +1,60 @@
+import { execFile, } from 'node:child_process';
+import { CliError } from '../../../errors/cli-error.js';
+function numericExitCode(error) {
+    return typeof error?.code === 'number' ? error.code : 0;
+}
+function spawnFailure(error) {
+    const code = typeof error.code === 'string' ? ` (${error.code})` : '';
+    return new CliError(`Unable to run the Git executable${code}: ${error.message || 'unknown process spawn error'}. Install Git and ensure it is available on PATH.`, 2);
+}
+function gitEnvironment(overrides) {
+    const env = {
+        ...process.env,
+        ...overrides,
+        LANG: 'C',
+        LANGUAGE: 'C',
+        LC_ALL: 'C',
+    };
+    for (const variable of [
+        'GIT_DIR',
+        'GIT_WORK_TREE',
+        'GIT_INDEX_FILE',
+        'GIT_COMMON_DIR',
+        'GIT_OBJECT_DIRECTORY',
+        'GIT_ALTERNATE_OBJECT_DIRECTORIES',
+        'GIT_NAMESPACE',
+        'GIT_CEILING_DIRECTORIES',
+    ]) {
+        delete env[variable];
+    }
+    return env;
+}
+export function createGitRunner(execFileImpl = execFile) {
+    return {
+        async run(args, options) {
+            const result = await new Promise((resolve, reject) => {
+                execFileImpl('git', args, {
+                    cwd: options.cwd,
+                    env: gitEnvironment(options.env),
+                    encoding: 'utf8',
+                }, (error, stdout, stderr) => {
+                    if (error && typeof error.code !== 'number') {
+                        reject(spawnFailure(error));
+                        return;
+                    }
+                    resolve({
+                        stdout: stdout.trim(),
+                        stderr: stderr.trim(),
+                        code: numericExitCode(error),
+                    });
+                });
+            });
+            if (result.code !== 0 && !options.allowFailure) {
+                const detail = result.stderr || result.stdout || 'unknown git error';
+                throw new CliError(`git ${args.join(' ')} failed (exit ${result.code}): ${detail}`, 2);
+            }
+            return result;
+        },
+    };
+}
+export const defaultGitRunner = createGitRunner();