@copado/agentia-cli 0.122.0-alpha.1 → 1.0.0-beta.1

package/dist/lib/var-replacement.js

@@ -1,153 +1,14 @@
-import { spawn } from 'node:child_process';
-import { access, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { getGatewayClientOrigin } from './cicd-gateway.js';
-import { logVerboseDebug } from './debug.js';
-const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
-export const VAR_REPLACE_COMMAND_JAR_NAME = 'var-replace-command.jar';
-function defaultRunProcess(command, args, options) {
-    return new Promise((resolvePromise, reject) => {
-        const child = spawn(command, args, {
-            cwd: options.cwd,
-            env: process.env,
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (chunk) => {
-            stdout += String(chunk);
-        });
-        child.stderr.on('data', (chunk) => {
-            stderr += String(chunk);
-        });
-        child.on('error', (error) => {
-            reject(error);
-        });
-        child.on('close', (code) => {
-            resolvePromise({ exitCode: code, stderr, stdout });
-        });
-    });
-}
-export function resolveVarReplaceCommandJar() {
-    const override = process.env.AGENTIA_VAR_REPLACE_COMMAND_JAR?.trim();
-    if (override !== undefined && override.length > 0) {
-        return override;
-    }
-    return join(packageRoot, 'vendor/java', VAR_REPLACE_COMMAND_JAR_NAME);
-}
-export function resolveVarReplacementJavaCommand() {
-    const override = process.env.AGENTIA_JAVA?.trim();
-    return override !== undefined && override.length > 0 ? override : 'java';
-}
-export function formatVarReplacementCommand(command, args) {
-    return [command, ...args].join(' ');
-}
-/** JSON path list consumed by var-replace-command `-c` / `--include`. */
-export function buildFilesInScopeJson(changedFiles) {
-    return `${JSON.stringify(changedFiles, null, 0)}\n`;
-}
-/** JSON consumed by var-replace-command `<replacements>`. */
-export function buildVarReplacementEntries(variables) {
-    const entries = [];
-    for (const variable of variables) {
-        const name = variable.name?.trim();
-        if (name === undefined || name.length === 0 || typeof variable.value !== 'string') {
-            continue;
-        }
-        const scope = variable.scope?.trim();
-        entries.push({
-            name,
-            scope: scope !== undefined && scope.length > 0 ? scope : '*',
-            value: variable.value,
-        });
-    }
-    return entries;
-}
-export function buildVarReplacementsJson(variables) {
-    return `${JSON.stringify(buildVarReplacementEntries(variables))}\n`;
-}
-function redactVarReplacementsForDebug(variables) {
-    return JSON.stringify(buildVarReplacementEntries(variables).map((entry) => ({
-        name: entry.name,
-        scope: entry.scope,
-        value: '[redacted]',
-    })), null, 2);
-}
-function logVarReplacementVerboseInput(options) {
-    logVerboseDebug('Var replacement command', formatVarReplacementCommand(options.command, options.args));
-    logVerboseDebug('Var replacement rules', redactVarReplacementsForDebug(options.environmentVariables));
-    logVerboseDebug('Var replacement files in scope', options.changedFiles.length > 0 ? options.changedFiles.join('\n') : '(empty)');
-}
-/** Emit var-replace-command process streams for normal CLI output. */
-export function emitVarReplacementProcessOutput(result) {
-    for (const stream of [result.stdout, result.stderr]) {
-        const trimmed = stream.trimEnd();
-        if (trimmed.length > 0) {
-            process.stderr.write(`${trimmed}\n`);
-        }
-    }
-}
-export async function runVarReplacement(options) {
-    const jarPath = resolveVarReplaceCommandJar();
-    try {
-        await access(jarPath);
-    }
-    catch {
-        throw new Error(`Variable replacement JAR not found at ${jarPath}. Run \`npm run build-java-dependencies\` or set AGENTIA_VAR_REPLACE_COMMAND_JAR.`);
-    }
-    const tempDir = await mkdtemp(join(tmpdir(), 'agentia-var-replace-'));
-    const replacementsPath = join(tempDir, 'replacements.json');
-    const includePath = join(tempDir, 'files-in-scope.json');
-    try {
-        await writeFile(replacementsPath, buildVarReplacementsJson(options.environmentVariables), 'utf8');
-        await writeFile(includePath, buildFilesInScopeJson(options.changedFiles), 'utf8');
-        const javaCommand = resolveVarReplacementJavaCommand();
-        // `-v` replaces environment values with `{!Environment.NAME}` placeholders (commit direction).
-        // `-d` allows the same variable name to appear for multiple environments.
-        const args = [
-            '-jar',
-            jarPath,
-            replacementsPath,
-            options.targetFolder,
-            '-v',
-            '-d',
-            '-c',
-            includePath,
-        ];
-        logVarReplacementVerboseInput({
-            args,
-            changedFiles: options.changedFiles,
-            command: javaCommand,
-            environmentVariables: options.environmentVariables,
-        });
-        const runProcess = options.runProcess ?? varReplacementProcessForTests() ?? defaultRunProcess;
-        const result = await runProcess(javaCommand, args, { cwd: options.cwd });
-        if (getGatewayClientOrigin() !== 'mcp') {
-            emitVarReplacementProcessOutput(result);
-        }
-        return {
-            args,
-            command: javaCommand,
-            exitCode: result.exitCode,
-            stderr: result.stderr,
-            stdout: result.stdout,
-        };
-    }
-    finally {
-        await rm(tempDir, { force: true, recursive: true });
-    }
-}
-let runProcessForTests;
-/** Test-only hook */
-export function setVarReplacementProcessForTests(runner) {
-    runProcessForTests = runner;
-}
-/** Test-only hook */
-export function resetVarReplacementProcessForTests() {
-    runProcessForTests = undefined;
-}
-export function varReplacementProcessForTests() {
-    return runProcessForTests;
-}
-//# sourceMappingURL=var-replacement.js.map
+import {modules} from './runtime.js';
+const VAR_REPLACE_COMMAND_JAR_NAME = modules["var-replacement.js"]["VAR_REPLACE_COMMAND_JAR_NAME"]
+const buildFilesInScopeJson = modules["var-replacement.js"]["buildFilesInScopeJson"]
+const buildVarReplacementEntries = modules["var-replacement.js"]["buildVarReplacementEntries"]
+const buildVarReplacementsJson = modules["var-replacement.js"]["buildVarReplacementsJson"]
+const emitVarReplacementProcessOutput = modules["var-replacement.js"]["emitVarReplacementProcessOutput"]
+const formatVarReplacementCommand = modules["var-replacement.js"]["formatVarReplacementCommand"]
+const resetVarReplacementProcessForTests = modules["var-replacement.js"]["resetVarReplacementProcessForTests"]
+const resolveVarReplaceCommandJar = modules["var-replacement.js"]["resolveVarReplaceCommandJar"]
+const resolveVarReplacementJavaCommand = modules["var-replacement.js"]["resolveVarReplacementJavaCommand"]
+const runVarReplacement = modules["var-replacement.js"]["runVarReplacement"]
+const setVarReplacementProcessForTests = modules["var-replacement.js"]["setVarReplacementProcessForTests"]
+const varReplacementProcessForTests = modules["var-replacement.js"]["varReplacementProcessForTests"]
+export {VAR_REPLACE_COMMAND_JAR_NAME, buildFilesInScopeJson, buildVarReplacementEntries, buildVarReplacementsJson, emitVarReplacementProcessOutput, formatVarReplacementCommand, resetVarReplacementProcessForTests, resolveVarReplaceCommandJar, resolveVarReplacementJavaCommand, runVarReplacement, setVarReplacementProcessForTests, varReplacementProcessForTests};

package/dist/lib/version-warning.js

@@ -3,6 +3,7 @@ import { fileURLToPath } from 'node:url';
 import { AGENTIA_RELEASE_CHANNEL, isNewerVersion, isVersionCacheStale, readVersionCache, versionCachePath, } from './cli-version.js';
 let spawnRefreshFn = spawnVersionRefresh;
 let spawnChildFn = spawn;
+const LOCAL_DEVELOPMENT_VERSION = '0.0.0-dev.0';
 export function setVersionRefreshSpawnerForTests(nextSpawner) {
     spawnRefreshFn = nextSpawner ?? spawnVersionRefresh;
 }
@@ -36,7 +37,7 @@ export function spawnVersionRefresh(cachePath) {
     child.unref();
 }
 export async function checkVersionWarning(options) {
-    if (options.skip || options.commandId === 'update') {
+    if (options.skip || options.commandId === 'update' || options.currentVersion === LOCAL_DEVELOPMENT_VERSION) {
         return { refreshStarted: false };
     }
     const cachePath = versionCachePath(options.cacheDir);

package/dist/lib/work-active.js

@@ -1,23 +1,4 @@
-import { readLastWorkItem, readLastWorkItemId } from './defaults-store.js';
-export class WorkActiveResolutionError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'WorkActiveResolutionError';
-    }
-}
-export async function resolveWorkItemId(explicitId) {
-    const trimmed = explicitId?.trim();
-    if (trimmed !== undefined && trimmed.length > 0) {
-        return trimmed;
-    }
-    const storedId = (await readLastWorkItemId())?.trim();
-    if (storedId !== undefined && storedId.length > 0) {
-        return storedId;
-    }
-    const storedName = (await readLastWorkItem())?.trim();
-    if (storedName !== undefined && storedName.length > 0) {
-        throw new WorkActiveResolutionError('Active work item ID is not recorded. Run `agentia cicd work set <id>` again to refresh local context.');
-    }
-    throw new WorkActiveResolutionError('No active work item. Run `agentia cicd work set <id>` or pass a user story ID.');
-}
-//# sourceMappingURL=work-active.js.map
+import {modules} from './runtime.js';
+const WorkActiveResolutionError = modules["work-active.js"]["WorkActiveResolutionError"]
+const resolveWorkItemId = modules["work-active.js"]["resolveWorkItemId"]
+export {WorkActiveResolutionError, resolveWorkItemId};

package/dist/lib/work-apex-test.js

@@ -1,265 +1,12 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { getMcpRequestSignal } from './mcp/request-context.js';
-const execFileAsync = promisify(execFile);
-export const DEFAULT_APEX_TEST_WAIT_MINUTES = 60;
-const APEX_TEST_MAX_BUFFER_BYTES = 32 * 1024 * 1024;
-const APEX_TEST_TIMEOUT_BUFFER_MS = 60_000;
-const APEX_CLASS_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*)?$/;
-const ORG_ID_PATTERN = /\b00D[A-Za-z0-9]{12,15}\b/g;
-const USER_ID_PATTERN = /\b005[A-Za-z0-9]{12,15}\b/g;
-const FAILED_OUTCOMES = new Set(['compilefail', 'fail']);
-export class WorkApexTestError extends Error {
-    result;
-    constructor(result) {
-        const failing = result.summary.failing ?? result.tests.filter((test) => isFailedOutcome(test.outcome)).length;
-        super(`Apex tests failed (${failing} failing).`);
-        this.name = 'WorkApexTestError';
-        this.result = result;
-    }
-}
-let sfApexTestExecFn = defaultSfApexTestExec;
-export function buildSfApexTestArgs(classNames, waitMinutes) {
-    return ['apex', 'run', 'test', '--class-names', ...classNames, '-c', '--json', '--wait', String(waitMinutes)];
-}
-export function parseApexTestClassNames(value) {
-    const names = value
-        .split(/[,\s]+/)
-        .map((name) => name.trim())
-        .filter((name) => name.length > 0);
-    if (names.length === 0) {
-        throw new Error('Requires `--apex-test-classes`.');
-    }
-    const unique = [];
-    const seen = new Set();
-    for (const name of names) {
-        if (!APEX_CLASS_NAME_PATTERN.test(name)) {
-            throw new Error(`Invalid Apex test class name '${name}'. Use identifiers such as MyTest or Namespace.MyTest.`);
-        }
-        if (seen.has(name)) {
-            continue;
-        }
-        seen.add(name);
-        unique.push(name);
-    }
-    return unique;
-}
-export function validateApexTestWaitMinutes(waitMinutes) {
-    if (!Number.isInteger(waitMinutes) || waitMinutes < 1) {
-        throw new Error('`--wait` must be a positive integer number of minutes.');
-    }
-    return waitMinutes;
-}
-export function formatWorkApexTestHuman(result) {
-    const failedTests = result.tests.filter((test) => isFailedOutcome(test.outcome));
-    const lines = [
-        `Apex tests: ${result.summary.outcome ?? (failedTests.length === 0 ? 'Passed' : 'Failed')}`,
-        ...summaryLines(result.summary),
-    ];
-    if (failedTests.length === 0) {
-        return lines.join('\n');
-    }
-    return [
-        ...lines,
-        '',
-        'Failed tests:',
-        ...failedTests.flatMap((test) => [
-            '',
-            testLabel(test),
-            ...(test.outcome === undefined ? [] : [`  Outcome: ${test.outcome}`]),
-            ...(test.message === undefined ? [] : [`  Message: ${test.message}`]),
-            ...(test.stackTrace === undefined ? [] : [`  StackTrace: ${test.stackTrace}`]),
-        ]),
-    ].join('\n');
-}
-export async function runWorkApexTests({ classNames, waitMinutes: requestedWaitMinutes, }) {
-    const waitMinutes = validateApexTestWaitMinutes(requestedWaitMinutes);
-    const args = buildSfApexTestArgs(classNames, waitMinutes);
-    let stdout;
-    try {
-        const executed = await sfApexTestExecFn(args, {
-            maxBuffer: APEX_TEST_MAX_BUFFER_BYTES,
-            signal: getMcpRequestSignal(),
-            timeout: waitMinutes * 60 * 1000 + APEX_TEST_TIMEOUT_BUFFER_MS,
-        });
-        stdout = executed.stdout;
-    }
-    catch (error) {
-        throw new Error(sanitizeApexTestError(error));
-    }
-    const parsed = extractJsonObject(stdout);
-    if (parsed.result === undefined) {
-        throw new Error(sanitizeApexTestError(parsed.message ?? parsed.name ?? 'Salesforce CLI Apex test run failed.'));
-    }
-    const result = parseSfApexTestJson(stdout, classNames, waitMinutes);
-    if (isTestRunFailed(result)) {
-        throw new WorkApexTestError(result);
-    }
-    if (typeof parsed.status === 'number' && parsed.status !== 0) {
-        throw new Error(sanitizeApexTestError(parsed.message ?? parsed.name ?? 'Salesforce CLI Apex test run failed.'));
-    }
-    return result;
-}
-export function parseSfApexTestJson(raw, classNames, waitMinutes) {
-    const parsed = extractJsonObject(raw);
-    if (parsed.result === undefined) {
-        throw new Error(sanitizeApexTestError(parsed.message ?? parsed.name ?? 'Salesforce CLI Apex test run failed.'));
-    }
-    const tests = (parsed.result.tests ?? []).flatMap((item) => {
-        const mapped = mapTestMethod(item);
-        return mapped === undefined ? [] : [mapped];
-    });
-    const summary = mapSummary(parsed.result.summary ?? {});
-    return {
-        classNames,
-        summary,
-        tests,
-        waitMinutes,
-    };
-}
-export function setSfApexTestExecForTests(fn) {
-    sfApexTestExecFn = fn;
-}
-export function resetSfApexTestExecForTests() {
-    sfApexTestExecFn = defaultSfApexTestExec;
-}
-async function defaultSfApexTestExec(args, options) {
-    try {
-        const { stderr, stdout } = await execFileAsync('sf', args, {
-            encoding: 'utf8',
-            maxBuffer: options.maxBuffer,
-            signal: options.signal,
-            timeout: options.timeout,
-        });
-        return { stderr: stderr.toString(), stdout: stdout.toString() };
-    }
-    catch (error) {
-        if (isExecFileError(error) && typeof error.stdout === 'string' && error.stdout.trim().length > 0) {
-            return {
-                stderr: typeof error.stderr === 'string' ? error.stderr : '',
-                stdout: error.stdout,
-            };
-        }
-        throw error;
-    }
-}
-function extractJsonObject(raw) {
-    const start = raw.indexOf('{');
-    if (start === -1) {
-        throw new Error('Salesforce CLI returned non-JSON output.');
-    }
-    return JSON.parse(raw.slice(start));
-}
-function mapSummary(summary) {
-    return {
-        ...(optionalString(summary.commandTime) === undefined ? {} : { commandTime: optionalString(summary.commandTime) }),
-        ...(optionalString(summary.failRate) === undefined ? {} : { failRate: optionalString(summary.failRate) }),
-        ...(optionalNumber(summary.failing) === undefined ? {} : { failing: optionalNumber(summary.failing) }),
-        ...(optionalString(summary.orgWideCoverage) === undefined
-            ? {}
-            : { orgWideCoverage: optionalString(summary.orgWideCoverage) }),
-        ...(optionalString(summary.outcome) === undefined ? {} : { outcome: optionalString(summary.outcome) }),
-        ...(optionalString(summary.passRate) === undefined ? {} : { passRate: optionalString(summary.passRate) }),
-        ...(optionalNumber(summary.passing) === undefined ? {} : { passing: optionalNumber(summary.passing) }),
-        ...(optionalNumber(summary.skipped) === undefined ? {} : { skipped: optionalNumber(summary.skipped) }),
-        ...(optionalString(summary.testExecutionTime) === undefined
-            ? {}
-            : { testExecutionTime: optionalString(summary.testExecutionTime) }),
-        ...(optionalString(summary.testRunCoverage) === undefined
-            ? {}
-            : { testRunCoverage: optionalString(summary.testRunCoverage) }),
-        ...(optionalString(summary.testRunId) === undefined ? {} : { testRunId: optionalString(summary.testRunId) }),
-        ...(optionalString(summary.testStartTime) === undefined
-            ? {}
-            : { testStartTime: optionalString(summary.testStartTime) }),
-        ...(optionalString(summary.testTotalTime) === undefined ? {} : { testTotalTime: optionalString(summary.testTotalTime) }),
-        ...(optionalNumber(summary.testsRan) === undefined ? {} : { testsRan: optionalNumber(summary.testsRan) }),
-    };
-}
-function mapTestMethod(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-        return undefined;
-    }
-    const record = value;
-    const apexClass = record.ApexClass !== null && typeof record.ApexClass === 'object' && !Array.isArray(record.ApexClass)
-        ? record.ApexClass
-        : undefined;
-    const mapped = {
-        ...(optionalString(apexClass?.Name) === undefined ? {} : { className: optionalString(apexClass?.Name) }),
-        ...(optionalString(record.FullName) === undefined ? {} : { fullName: optionalString(record.FullName) }),
-        ...(optionalString(record.Message) === undefined ? {} : { message: optionalString(record.Message) }),
-        ...(optionalString(record.MethodName) === undefined ? {} : { methodName: optionalString(record.MethodName) }),
-        ...(optionalString(record.Outcome) === undefined ? {} : { outcome: optionalString(record.Outcome) }),
-        ...(optionalString(record.StackTrace) === undefined ? {} : { stackTrace: optionalString(record.StackTrace) }),
-    };
-    return Object.keys(mapped).length === 0 ? undefined : mapped;
-}
-function isTestRunFailed(result) {
-    if (result.tests.some((test) => isFailedOutcome(test.outcome))) {
-        return true;
-    }
-    const outcome = result.summary.outcome?.trim().toLowerCase();
-    return outcome === 'failed' || (result.summary.failing ?? 0) > 0;
-}
-function isFailedOutcome(outcome) {
-    return outcome !== undefined && FAILED_OUTCOMES.has(outcome.trim().toLowerCase());
-}
-function testLabel(test) {
-    if (test.fullName !== undefined && test.fullName.length > 0) {
-        return test.fullName;
-    }
-    const joined = [test.className, test.methodName]
-        .filter((part) => part !== undefined && part.length > 0)
-        .join('.');
-    return joined.length > 0 ? joined : 'unknown test';
-}
-function summaryLines(summary) {
-    const lines = [];
-    pushLine(lines, 'Tests ran', summary.testsRan);
-    pushLine(lines, 'Passing', summary.passing);
-    pushLine(lines, 'Failing', summary.failing);
-    pushLine(lines, 'Skipped', summary.skipped);
-    pushLine(lines, 'Pass rate', summary.passRate);
-    pushLine(lines, 'Fail rate', summary.failRate);
-    pushLine(lines, 'Test run coverage', summary.testRunCoverage);
-    pushLine(lines, 'Org-wide coverage', summary.orgWideCoverage);
-    pushLine(lines, 'Test execution time', summary.testExecutionTime);
-    return lines;
-}
-function pushLine(lines, label, value) {
-    if (value === undefined || value === '') {
-        return;
-    }
-    lines.push(`${label}: ${value}`);
-}
-function optionalString(value) {
-    if (typeof value !== 'string') {
-        return undefined;
-    }
-    const sanitized = sanitizeIdentity(value).trim();
-    return sanitized.length === 0 ? undefined : sanitized;
-}
-function optionalNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
-function sanitizeApexTestError(error) {
-    if (isExecFileError(error) && error.code === 'ENOENT') {
-        return 'Salesforce CLI (`sf`) is not installed or is not on PATH.';
-    }
-    if (error instanceof Error && error.name === 'AbortError') {
-        return 'Apex test run was cancelled.';
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    const cleaned = sanitizeIdentity(message).trim();
-    if (cleaned.length === 0) {
-        return 'Salesforce CLI Apex test run failed.';
-    }
-    return `Salesforce CLI Apex test run failed: ${cleaned}`;
-}
-function sanitizeIdentity(value) {
-    return value.replaceAll(ORG_ID_PATTERN, '<org-id>').replaceAll(USER_ID_PATTERN, '<user-id>');
-}
-function isExecFileError(error) {
-    return error instanceof Error;
-}
-//# sourceMappingURL=work-apex-test.js.map
+import {modules} from './runtime.js';
+const DEFAULT_APEX_TEST_WAIT_MINUTES = modules["work-apex-test.js"]["DEFAULT_APEX_TEST_WAIT_MINUTES"]
+const WorkApexTestError = modules["work-apex-test.js"]["WorkApexTestError"]
+const buildSfApexTestArgs = modules["work-apex-test.js"]["buildSfApexTestArgs"]
+const formatWorkApexTestHuman = modules["work-apex-test.js"]["formatWorkApexTestHuman"]
+const parseApexTestClassNames = modules["work-apex-test.js"]["parseApexTestClassNames"]
+const parseSfApexTestJson = modules["work-apex-test.js"]["parseSfApexTestJson"]
+const resetSfApexTestExecForTests = modules["work-apex-test.js"]["resetSfApexTestExecForTests"]
+const runWorkApexTests = modules["work-apex-test.js"]["runWorkApexTests"]
+const setSfApexTestExecForTests = modules["work-apex-test.js"]["setSfApexTestExecForTests"]
+const validateApexTestWaitMinutes = modules["work-apex-test.js"]["validateApexTestWaitMinutes"]
+export {DEFAULT_APEX_TEST_WAIT_MINUTES, WorkApexTestError, buildSfApexTestArgs, formatWorkApexTestHuman, parseApexTestClassNames, parseSfApexTestJson, resetSfApexTestExecForTests, runWorkApexTests, setSfApexTestExecForTests, validateApexTestWaitMinutes};

package/dist/lib/work-branch-metadata.js

@@ -1,40 +1,4 @@
-import { readLastBaseBranch } from './defaults-store.js';
-import { resolvedSelectionsFromChangedFiles } from './dependency-from-changes.js';
-const NO_METADATA_MESSAGES = [
-    'No changed files were found',
-    'No resolvable metadata selections were found',
-];
-function isNoMetadataError(error) {
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    return NO_METADATA_MESSAGES.some((message) => error.message.startsWith(message));
-}
-export async function resolveWorkBranchMetadata(baseRef, moduleType) {
-    try {
-        const selections = await resolvedSelectionsFromChangedFiles(baseRef, moduleType);
-        return {
-            baseRef,
-            metadataList: selections.map(({ localPaths, selection }) => ({
-                localPaths,
-                name: selection.name,
-                type: selection.type,
-            })),
-        };
-    }
-    catch (error) {
-        if (!isNoMetadataError(error)) {
-            throw error;
-        }
-        return { baseRef, metadataList: [] };
-    }
-}
-/** Local branch metadata when `work set` recorded lastBaseBranch; otherwise undefined. */
-export async function resolveRecordedWorkBranchMetadata(moduleType) {
-    const baseRef = (await readLastBaseBranch())?.trim();
-    if (!baseRef) {
-        return undefined;
-    }
-    return resolveWorkBranchMetadata(baseRef, moduleType);
-}
-//# sourceMappingURL=work-branch-metadata.js.map
+import {modules} from './runtime.js';
+const resolveRecordedWorkBranchMetadata = modules["work-branch-metadata.js"]["resolveRecordedWorkBranchMetadata"]
+const resolveWorkBranchMetadata = modules["work-branch-metadata.js"]["resolveWorkBranchMetadata"]
+export {resolveRecordedWorkBranchMetadata, resolveWorkBranchMetadata};