@open-agent-toolkit/cli 0.2.40 → 0.2.45

package/dist/commands/project/new/scaffold.js

@@ -1,15 +1,31 @@
-import { execFileSync } from 'node:child_process';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { ensureScopedRootGitignore } from '../../init/gitignore.js';
 import { instantiateProjectLogTemplate } from '../../project/log/append.js';
+import { defaultGitRunner } from '../../project/sync/git.js';
+import { buildSyncedRecord, writeSyncedRecord, } from '../../project/sync/record.js';
+import { buildSyncTarget, commitRecordChange, createSyncedProject, pushSynced, rollbackCreatedSyncedProject, } from '../../project/sync/ref-sync.js';
 import { resolveProjectsRoot } from '../../shared/oat-paths.js';
+import { canonicalizePath, PROJECT_SCOPES, resolveDefaultScope, resolveScopeRoot, syncedRecordPath, } from '../../shared/project-scope.js';
 import { generateStateDashboard } from '../../state/generate.js';
 import { setActiveProject } from '../../../config/oat-config.js';
 import { resolveEffectiveConfig } from '../../../config/resolve.js';
+import { CliError } from '../../../errors/cli-error.js';
 import { resolveAssetsRoot } from '../../../fs/assets.js';
-import { fileExists } from '../../../fs/io.js';
+import { dirExists, fileExists } from '../../../fs/io.js';
 import { assertValidProjectStateContent } from '../../../validation/project-state.js';
+const DEFAULT_DEPENDENCIES = {
+    resolveDefaultScope,
+    gitRunner: defaultGitRunner,
+    createSyncedProject,
+    pushSynced,
+    commitRecordChange,
+    rollbackCreatedSyncedProject,
+    writeSyncedRecord,
+    ensureScopedRootGitignore,
+    setActiveProject,
+};
 const TEMPLATES_BY_MODE = {
     'spec-driven': [
         'state.md',
@@ -95,12 +111,15 @@ function assertNoUnresolvedOatPlaceholders(rendered, templateFile) {
 }
 function validateProjectName(name) {
     if (name.startsWith('-')) {
-        throw new Error(`Invalid project name "${name}". Project names must not start with a dash.`);
+        throw new CliError(`Invalid project name "${name}". Project names must not start with a dash.`, 1);
     }
     if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
-        throw new Error(`Invalid project name "${name}". Use only letters, numbers, dash, and underscore.`);
+        throw new CliError(`Invalid project name "${name}". Use only letters, numbers, dash, and underscore.`, 1);
     }
 }
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
 function applyTemplateReplacements(template, projectName, today, nowUtc, mode) {
     const stateContent = STATE_TEMPLATE_BY_MODE[mode];
     const oatReplacements = {
@@ -135,18 +154,9 @@ async function defaultRefreshDashboard(repoRoot) {
  * git failure; on failure the captured git stderr is surfaced via `error`. This
  * never throws: any git error is classified as `failed`, not propagated.
  */
-function commitScaffold(cwd, projectPath, projectName, createdFiles) {
-    const run = (args) => execFileSync('git', args, {
-        cwd,
-        encoding: 'utf8',
-        // Capture stderr instead of inheriting it so deliberate skip/failure
-        // probes (e.g. tests) do not leak raw `git fatal:` lines to the terminal.
-        stdio: ['ignore', 'pipe', 'pipe'],
-    }).trim();
-    try {
-        run(['rev-parse', '--is-inside-work-tree']);
-    }
-    catch {
+async function commitScaffold(cwd, absoluteProjectPath, projectName, createdFiles, dependencies) {
+    const inWorktree = await dependencies.gitRunner.run(['rev-parse', '--is-inside-work-tree'], { cwd, allowFailure: true });
+    if (inWorktree.code !== 0) {
         return { status: 'skipped_no_worktree', committed: false };
     }
     // Only commit files this run created. Nothing created => nothing to commit,
@@ -154,38 +164,30 @@ function commitScaffold(cwd, projectPath, projectName, createdFiles) {
     if (createdFiles.length === 0) {
         return { status: 'skipped_nothing', committed: false };
     }
-    const pathspecs = createdFiles.map((file) => join(projectPath, file));
+    const pathspecs = createdFiles.map((file) => join(absoluteProjectPath, file));
     try {
-        run(['add', '--', ...pathspecs]);
-        const staged = run(['diff', '--cached', '--name-only', '--', ...pathspecs]);
-        if (staged.length === 0) {
+        const commit = await dependencies.commitRecordChange(cwd, pathspecs, `chore(oat): scaffold ${projectName}`, dependencies.gitRunner, {
+            projectRoots: {
+                sharedRoot: dirname(absoluteProjectPath),
+                syncedRoot: join(dirname(dirname(absoluteProjectPath)), 'synced'),
+            },
+        });
+        if (!commit) {
             return { status: 'skipped_nothing', committed: false };
         }
-        run([
-            'commit',
-            '-m',
-            `chore(oat): scaffold ${projectName}`,
-            '--',
-            ...pathspecs,
-        ]);
-        const commitSha = run(['rev-parse', 'HEAD']);
-        return { status: 'committed', committed: true, commitSha };
+        return { status: 'committed', committed: true, commitSha: commit.sha };
     }
     catch (error) {
-        const stderr = error && typeof error === 'object' && 'stderr' in error
-            ? error.stderr
-            : undefined;
-        const message = (stderr != null ? stderr.toString().trim() : '') ||
-            (error instanceof Error ? error.message : String(error));
+        const message = error instanceof Error ? error.message : String(error);
         return { status: 'failed', committed: false, error: message };
     }
 }
-async function scaffoldModeTemplates(userOatRoot, repoRoot, projectPath, projectName, mode, today, nowUtc) {
+async function scaffoldModeTemplates(userOatRoot, repoRoot, absoluteProjectPath, projectName, mode, today, nowUtc) {
     const createdFiles = [];
     const skippedFiles = [];
     for (const templateFile of TEMPLATES_BY_MODE[mode]) {
         const src = await resolveTemplateSource(userOatRoot, repoRoot, templateFile);
-        const dest = join(repoRoot, projectPath, templateFile);
+        const dest = join(absoluteProjectPath, templateFile);
         if (await fileExists(dest)) {
             skippedFiles.push(templateFile);
             continue;
@@ -201,9 +203,9 @@ async function scaffoldModeTemplates(userOatRoot, repoRoot, projectPath, project
     }
     return { createdFiles, skippedFiles };
 }
-async function scaffoldProjectLog(userOatRoot, repoRoot, projectPath, projectName, today) {
+async function scaffoldProjectLog(userOatRoot, repoRoot, absoluteProjectPath, projectName, today) {
     const templateFile = 'project-log.md';
-    const dest = join(repoRoot, projectPath, templateFile);
+    const dest = join(absoluteProjectPath, templateFile);
     if (await fileExists(dest)) {
         return 'skipped';
     }
@@ -224,13 +226,12 @@ async function resolveTemplateSource(userOatRoot, repoRoot, templateFile) {
     const assetsRoot = await resolveAssetsRoot();
     return join(assetsRoot, 'templates', templateFile);
 }
-async function ensureStructure(repoRoot, projectPath, mode) {
-    const projectRoot = join(repoRoot, projectPath);
-    await mkdir(projectRoot, { recursive: true });
-    await mkdir(join(projectRoot, 'reviews'), { recursive: true });
-    await mkdir(join(projectRoot, 'pr'), { recursive: true });
+async function ensureStructure(absoluteProjectPath, mode) {
+    await mkdir(absoluteProjectPath, { recursive: true });
+    await mkdir(join(absoluteProjectPath, 'reviews'), { recursive: true });
+    await mkdir(join(absoluteProjectPath, 'pr'), { recursive: true });
     if (mode === 'import') {
-        const referencesDir = join(projectRoot, 'references');
+        const referencesDir = join(absoluteProjectPath, 'references');
         await mkdir(referencesDir, { recursive: true });
         const gitkeepPath = join(referencesDir, '.gitkeep');
         if (!(await fileExists(gitkeepPath))) {
@@ -238,7 +239,53 @@ async function ensureStructure(repoRoot, projectPath, mode) {
         }
     }
 }
-export async function scaffoldProject(options) {
+async function ensureScopedProjectIgnored(repoRoot, absoluteScopeRoot, scope, dependencies) {
+    return dependencies.ensureScopedRootGitignore(repoRoot, absoluteScopeRoot, scope, dependencies.gitRunner, 'Cannot add the configured project-root rule because .gitignore has staged or unstaged changes; commit or stash those changes, then retry.');
+}
+async function assertCrossScopeSlugAvailable(repoRoot, projectsRoot, projectName, targetScope, dependencies) {
+    const collisions = [];
+    for (const scope of PROJECT_SCOPES) {
+        if (scope === targetScope)
+            continue;
+        const scopeRoot = resolveScopeRoot(repoRoot, projectsRoot, scope);
+        if (await dirExists(join(scopeRoot, projectName))) {
+            collisions.push(scope);
+            continue;
+        }
+        if (scope === 'synced' &&
+            (await fileExists(syncedRecordPath(scopeRoot, projectName)))) {
+            collisions.push(scope);
+        }
+    }
+    if (targetScope !== 'synced' && !collisions.includes('synced')) {
+        const workTree = await dependencies.gitRunner.run(['rev-parse', '--is-inside-work-tree'], { cwd: repoRoot, allowFailure: true });
+        if (workTree.code === 0) {
+            const syncedTarget = buildSyncTarget(repoRoot, projectsRoot, projectName);
+            const localRef = await dependencies.gitRunner.run(['show-ref', '--verify', '--quiet', syncedTarget.ref], { cwd: repoRoot, allowFailure: true });
+            if (localRef.code !== 0 && localRef.code !== 1) {
+                throw new CliError(`Unable to check synced project collision for ${projectName}: ${localRef.stderr || localRef.stdout || 'git show-ref failed'}`, 2);
+            }
+            if (localRef.code === 0) {
+                collisions.push('synced');
+            }
+            const remote = await dependencies.gitRunner.run(['remote', 'get-url', 'origin'], { cwd: repoRoot, allowFailure: true });
+            if (remote.code === 0 && localRef.code === 1) {
+                const remoteRef = await dependencies.gitRunner.run(['ls-remote', '--exit-code', syncedTarget.remote, syncedTarget.ref], { cwd: repoRoot, allowFailure: true });
+                if (remoteRef.code === 0) {
+                    collisions.push('synced');
+                }
+                else if (remoteRef.code !== 2) {
+                    console.error(`Warning: unable to verify remote synced project collision for ${projectName}; continuing ${targetScope} project creation: ${remoteRef.stderr || remoteRef.stdout || 'git ls-remote failed'}`);
+                }
+            }
+        }
+    }
+    if (collisions.length > 0) {
+        throw new CliError(`Project name "${projectName}" already exists in ${collisions.join(', ')} scope. Choose a unique name, or pass --force and use an explicit project path when opening the duplicate.`, 1);
+    }
+}
+export async function scaffoldProject(options, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
     const mode = options.mode ?? 'spec-driven';
     const setActive = options.setActive ?? true;
     const refreshDashboard = options.refreshDashboard ?? true;
@@ -254,25 +301,197 @@ export async function scaffoldProject(options) {
     const nowUtc = options.nowUtc ?? now.toISOString();
     validateProjectName(options.projectName);
     const projectsRoot = await resolveProjectsRoot(options.repoRoot, env);
-    const projectPath = join(projectsRoot, options.projectName);
-    // `--force` is currently accepted for compatibility with the legacy script.
-    // Scaffold behavior is always non-destructive (create missing files only).
-    void options.force;
-    await ensureStructure(options.repoRoot, projectPath, mode);
-    const { createdFiles, skippedFiles } = await scaffoldModeTemplates(userOatRoot, options.repoRoot, projectPath, options.projectName, mode, today, nowUtc);
-    const effectiveProjectLog = options.projectLog ??
-        (await resolveEffectiveConfig(options.repoRoot, userOatRoot, env)).resolved['workflow.projectLog']?.value === true;
-    if (effectiveProjectLog) {
-        const projectLogResult = await scaffoldProjectLog(userOatRoot, options.repoRoot, projectPath, options.projectName, today);
-        if (projectLogResult === 'created') {
-            createdFiles.push('project-log.md');
+    const scope = options.scope ??
+        (await dependencies.resolveDefaultScope(options.repoRoot, env));
+    const absoluteScopeRoot = canonicalizePath(scope === 'shared'
+        ? resolve(options.repoRoot, projectsRoot)
+        : resolveScopeRoot(options.repoRoot, projectsRoot, scope));
+    const absoluteProjectPath = canonicalizePath(join(absoluteScopeRoot, options.projectName));
+    const relativeProjectPath = relative(canonicalizePath(options.repoRoot), absoluteProjectPath);
+    const projectPath = relativeProjectPath === '..' ||
+        relativeProjectPath.startsWith('../') ||
+        relativeProjectPath.startsWith('..\\') ||
+        isAbsolute(relativeProjectPath)
+        ? absoluteProjectPath
+        : relativeProjectPath.split('\\').join('/');
+    if (scope === 'synced') {
+        const canonicalRepoRoot = canonicalizePath(options.repoRoot);
+        const relativeSyncedRoot = relative(canonicalRepoRoot, absoluteScopeRoot);
+        if (relativeSyncedRoot === '' ||
+            relativeSyncedRoot === '..' ||
+            relativeSyncedRoot.startsWith('../') ||
+            relativeSyncedRoot.startsWith('..\\') ||
+            isAbsolute(relativeSyncedRoot)) {
+            throw new CliError(`Cannot create synced project ${options.projectName}: the configured synced project root \`${absoluteScopeRoot}\` is outside repository \`${canonicalRepoRoot}\`. Use an in-repository projects.root for synced scope, or choose shared/local scope for external storage.`, 1);
+        }
+    }
+    if (!options.force) {
+        await assertCrossScopeSlugAvailable(options.repoRoot, projectsRoot, options.projectName, scope, dependencies);
+    }
+    let gitignoreChanged = false;
+    let gitignoreBefore;
+    let syncTarget;
+    let syncedCreatedByInvocation = false;
+    let published = false;
+    let recordWritten = false;
+    let ref;
+    let sha;
+    let recordPath;
+    let parentHeadBeforeRecordCommit;
+    let committed = false;
+    let commitSha;
+    let commitStatus = 'skipped_disabled';
+    let commitError;
+    let createdFiles = [];
+    let skippedFiles = [];
+    try {
+        if (scope === 'local') {
+            const repair = await ensureScopedProjectIgnored(options.repoRoot, absoluteScopeRoot, scope, dependencies);
+            if (repair.changed) {
+                console.error('Warning: applied the OAT local-project rule to .gitignore before scaffolding.');
+            }
+        }
+        if (scope === 'synced') {
+            const remote = await dependencies.gitRunner.run(['remote', 'get-url', 'origin'], { cwd: options.repoRoot, allowFailure: true });
+            if (remote.code !== 0) {
+                throw new CliError('Synced project creation requires a configured origin remote. Configure origin or use --scope local.', 1);
+            }
+            const repair = await ensureScopedProjectIgnored(options.repoRoot, absoluteScopeRoot, scope, dependencies);
+            gitignoreBefore = repair.before;
+            gitignoreChanged = repair.changed;
+            if (gitignoreChanged) {
+                console.error('Warning: applied the OAT synced-project rule to .gitignore before scaffolding.');
+            }
+            syncTarget = buildSyncTarget(options.repoRoot, projectsRoot, options.projectName);
+            await dependencies.createSyncedProject(syncTarget, dependencies.gitRunner);
+            syncedCreatedByInvocation = true;
+        }
+        await ensureStructure(absoluteProjectPath, mode);
+        ({ createdFiles, skippedFiles } = await scaffoldModeTemplates(userOatRoot, options.repoRoot, absoluteProjectPath, options.projectName, mode, today, nowUtc));
+        const effectiveProjectLog = options.projectLog ??
+            (await resolveEffectiveConfig(options.repoRoot, userOatRoot, env))
+                .resolved['workflow.projectLog']?.value === true;
+        if (effectiveProjectLog) {
+            const projectLogResult = await scaffoldProjectLog(userOatRoot, options.repoRoot, absoluteProjectPath, options.projectName, today);
+            if (projectLogResult === 'created') {
+                createdFiles.push('project-log.md');
+            }
+            else {
+                skippedFiles.push('project-log.md');
+            }
+        }
+        if (scope === 'synced' && syncTarget) {
+            const pushed = await dependencies.pushSynced(syncTarget, dependencies.gitRunner, { message: `chore(oat): scaffold ${options.projectName}` });
+            if (pushed.status !== 'pushed' && pushed.status !== 'up-to-date') {
+                throw new CliError(`Unable to publish synced project ${options.projectName}: ${pushed.status}.`, 1);
+            }
+            published = true;
+            ref = syncTarget.ref;
+            sha = pushed.sha;
+            recordPath = syncedRecordPath(absoluteScopeRoot, options.projectName);
+            await dependencies.writeSyncedRecord(recordPath, buildSyncedRecord(options.projectName, new Date(nowUtc)));
+            recordWritten = true;
+            if (options.commit) {
+                parentHeadBeforeRecordCommit = (await dependencies.gitRunner.run(['rev-parse', 'HEAD'], {
+                    cwd: options.repoRoot,
+                })).stdout;
+                const recordCommit = await dependencies.commitRecordChange(options.repoRoot, [recordPath, ...(gitignoreChanged ? ['.gitignore'] : [])], `chore(oat): scaffold ${options.projectName}`, dependencies.gitRunner, { projectRoots: syncTarget });
+                committed = recordCommit !== null;
+                commitSha = recordCommit?.sha;
+                commitStatus = recordCommit ? 'committed' : 'skipped_nothing';
+            }
+        }
+    }
+    catch (error) {
+        if (scope === 'synced' && syncTarget && !published) {
+            if (syncedCreatedByInvocation) {
+                await dependencies.rollbackCreatedSyncedProject(syncTarget, dependencies.gitRunner);
+            }
+            if (gitignoreChanged && gitignoreBefore !== undefined) {
+                const gitignorePath = join(options.repoRoot, '.gitignore');
+                if (gitignoreBefore === null) {
+                    await rm(gitignorePath, { force: true });
+                }
+                else {
+                    await writeFile(gitignorePath, gitignoreBefore, 'utf8');
+                }
+            }
         }
-        else {
-            skippedFiles.push('project-log.md');
+        if (scope === 'synced' && published && syncTarget && recordPath) {
+            const detail = error instanceof Error ? error.message : String(error);
+            const currentParentHead = parentHeadBeforeRecordCommit
+                ? (await dependencies.gitRunner.run(['rev-parse', 'HEAD'], {
+                    cwd: options.repoRoot,
+                })).stdout
+                : undefined;
+            const canRollbackPublishedScaffold = syncedCreatedByInvocation &&
+                sha !== undefined &&
+                (parentHeadBeforeRecordCommit === undefined ||
+                    currentParentHead === parentHeadBeforeRecordCommit);
+            if (canRollbackPublishedScaffold) {
+                try {
+                    await dependencies.gitRunner.run([
+                        'push',
+                        `--force-with-lease=${syncTarget.ref}:${sha}`,
+                        syncTarget.remote,
+                        `:${syncTarget.ref}`,
+                    ], { cwd: options.repoRoot });
+                    await dependencies.gitRunner.run([
+                        'reset',
+                        '-q',
+                        '--',
+                        relative(canonicalizePath(options.repoRoot), recordPath)
+                            .split('\\')
+                            .join('/'),
+                        ...(gitignoreChanged ? ['.gitignore'] : []),
+                    ], { cwd: options.repoRoot });
+                    await rm(recordPath, { force: true });
+                    await dependencies.rollbackCreatedSyncedProject(syncTarget, dependencies.gitRunner);
+                    if (gitignoreChanged && gitignoreBefore !== undefined) {
+                        const gitignorePath = join(options.repoRoot, '.gitignore');
+                        if (gitignoreBefore === null) {
+                            await rm(gitignorePath, { force: true });
+                        }
+                        else {
+                            await writeFile(gitignorePath, gitignoreBefore, 'utf8');
+                        }
+                    }
+                    throw new CliError(`Synced project ${options.projectName} scaffold failed and its attempt-owned ref, checkout, and record were rolled back: ${detail}. Retry project creation after correcting the failure.`, error instanceof CliError ? error.exitCode : 2);
+                }
+                catch (rollbackError) {
+                    if (rollbackError instanceof CliError &&
+                        rollbackError.message.includes('were rolled back')) {
+                        throw rollbackError;
+                    }
+                    const rollbackDetail = rollbackError instanceof Error
+                        ? rollbackError.message
+                        : String(rollbackError);
+                    throw new CliError(`Synced project ${options.projectName} scaffold failed: ${detail}. Automatic rollback also failed: ${rollbackDetail}. Preserve the checkout and run oat project prune ${options.projectName} --force after verifying the remote ref.`, 2);
+                }
+            }
+            if (!recordWritten) {
+                throw new CliError(`Synced project ${options.projectName} was published, but its discovery record was not written: ${detail}. Run oat project pull '${options.projectName}' to resume record adoption; do not rerun project creation.`, 2);
+            }
+            const relativeRecordPath = relative(canonicalizePath(options.repoRoot), recordPath)
+                .split('\\')
+                .join('/');
+            throw new CliError(`Synced project ${options.projectName} and its discovery record were written, but the parent commit failed: ${detail}. Repair Git, then run git add -- '${relativeRecordPath}'${gitignoreChanged ? " '.gitignore'" : ''} && git commit -m 'chore(oat): scaffold ${options.projectName}' -- '${relativeRecordPath}'${gitignoreChanged ? " '.gitignore'" : ''}; do not rerun project creation.`, 2);
         }
+        throw error;
     }
+    let activePointerUpdated = false;
     if (setActive) {
-        await setActiveProject(options.repoRoot, projectPath);
+        try {
+            await dependencies.setActiveProject(options.repoRoot, projectPath);
+            activePointerUpdated = true;
+        }
+        catch (error) {
+            if (scope === 'synced' && published) {
+                const detail = error instanceof Error ? error.message : String(error);
+                throw new CliError(`Synced project ${options.projectName} was published and recorded, but its active pointer was not updated: ${detail}. Run oat project open ${shellQuote(projectPath)} to complete recovery; do not rerun project creation.`, 2);
+            }
+            throw error;
+        }
     }
     let dashboardRefreshed = false;
     if (refreshDashboard) {
@@ -284,14 +503,10 @@ export async function scaffoldProject(options) {
             console.error(`Warning: dashboard refresh failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    let committed = false;
-    let commitSha;
-    let commitStatus = 'skipped_disabled';
-    let commitError;
-    if (options.commit) {
+    if (options.commit && scope === 'shared') {
         // `projectPath` is relative to `repoRoot`, so git must run there for the
         // pathspecs to resolve to the scaffolded files.
-        const commitResult = commitScaffold(options.repoRoot, projectPath, options.projectName, createdFiles);
+        const commitResult = await commitScaffold(options.repoRoot, absoluteProjectPath, options.projectName, createdFiles, dependencies);
         committed = commitResult.committed;
         commitSha = commitResult.commitSha;
         commitStatus = commitResult.status;
@@ -299,15 +514,18 @@ export async function scaffoldProject(options) {
     }
     return {
         mode,
+        scope,
         projectsRoot,
         projectPath,
         createdFiles,
         skippedFiles,
-        activePointerUpdated: setActive,
+        activePointerUpdated,
         dashboardRefreshed,
         committed,
         commitSha,
         commitStatus,
         commitError,
+        ref,
+        sha,
     };
 }

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

@@ -1,5 +1,9 @@
 import { readFile as defaultReadFile, writeFile as defaultWriteFile } from 'node:fs/promises';
 import { buildCommandContext, type CommandContext } from '../../../app/command-context.js';
+import { type GitRunner } from '../../project/sync/git.js';
+import { readSyncedRecord } from '../../project/sync/record.js';
+import { commitRecordChange as defaultCommitRecordChange, type PullResult, type PushResult, type AdoptionRecordState, type SyncTarget } from '../../project/sync/ref-sync.js';
+import { resolveSyncedTarget } from '../../project/sync/resolve-target.js';
 import { type GenerateStateResult } from '../../state/generate.js';
 import { type OatLocalConfig } from '../../../config/oat-config.js';
 import { dirExists, fileExists } from '../../../fs/io.js';
@@ -18,6 +22,18 @@ interface ProjectOpenDependencies {
     writeFile: typeof defaultWriteFile;
     dirExists: typeof dirExists;
     fileExists: typeof fileExists;
+    readSyncedRecord: typeof readSyncedRecord;
+    resolveSyncedTarget: typeof resolveSyncedTarget;
+    pullSynced: (target: SyncTarget, git: GitRunner, options?: {
+        adopt?: boolean;
+        adoptionRecord?: AdoptionRecordState;
+        now?: Date;
+    }) => Promise<PullResult>;
+    pushSynced: (target: SyncTarget, git: GitRunner, options: {
+        message?: string;
+    }) => Promise<PushResult>;
+    commitRecordChange: typeof defaultCommitRecordChange;
+    gitRunner: GitRunner;
     processEnv: NodeJS.ProcessEnv;
     now: () => Date;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/open/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,IAAI,eAAe,EAC3B,SAAS,IAAI,gBAAgB,EAC9B,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,mBAAmB,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAYhF,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,KAAK,cAAc,EAIpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAG/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,UAAU,uBAAuB;IAC/B,mBAAmB,EAAE,CACnB,OAAO,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,KAC/C,cAAc,CAAC;IACpB,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,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,cAAc,KACnB,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,sBAAsB,EAAE,CAAC,OAAO,EAAE;QAChC,QAAQ,EAAE,MAAM,CAAC;KAClB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACnC,QAAQ,EAAE,OAAO,eAAe,CAAC;IACjC,SAAS,EAAE,OAAO,gBAAgB,CAAC;IACnC,SAAS,EAAE,OAAO,SAAS,CAAC;IAC5B,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;IAC9B,GAAG,EAAE,MAAM,IAAI,CAAC;CACjB;AAkKD,wBAAgB,wBAAwB,CACtC,SAAS,GAAE,OAAO,CAAC,uBAAuB,CAAM,GAC/C,OAAO,CAkBT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/open/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,IAAI,eAAe,EAC3B,SAAS,IAAI,gBAAgB,EAC9B,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,mBAAmB,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAChF,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EACL,kBAAkB,IAAI,yBAAyB,EAG/C,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,mBAAmB,EACxB,KAAK,UAAU,EAChB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,mBAAmB,EAEpB,MAAM,uCAAuC,CAAC;AAmB/C,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,KAAK,cAAc,EAIpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAG/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,UAAU,uBAAuB;IAC/B,mBAAmB,EAAE,CACnB,OAAO,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,KAC/C,cAAc,CAAC;IACpB,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,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,cAAc,KACnB,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,sBAAsB,EAAE,CAAC,OAAO,EAAE;QAChC,QAAQ,EAAE,MAAM,CAAC;KAClB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACnC,QAAQ,EAAE,OAAO,eAAe,CAAC;IACjC,SAAS,EAAE,OAAO,gBAAgB,CAAC;IACnC,SAAS,EAAE,OAAO,SAAS,CAAC;IAC5B,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,gBAAgB,EAAE,OAAO,gBAAgB,CAAC;IAC1C,mBAAmB,EAAE,OAAO,mBAAmB,CAAC;IAChD,UAAU,EAAE,CACV,MAAM,EAAE,UAAU,EAClB,GAAG,EAAE,SAAS,EACd,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,cAAc,CAAC,EAAE,mBAAmB,CAAC;QACrC,GAAG,CAAC,EAAE,IAAI,CAAC;KACZ,KACE,OAAO,CAAC,UAAU,CAAC,CAAC;IACzB,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,kBAAkB,EAAE,OAAO,yBAAyB,CAAC;IACrD,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;IAC9B,GAAG,EAAE,MAAM,IAAI,CAAC;CACjB;AAgXD,wBAAgB,wBAAwB,CACtC,SAAS,GAAE,OAAO,CAAC,uBAAuB,CAAM,GAC/C,OAAO,CAkBT"}