poe-code 3.0.375 → 3.0.377-beta.1

package/packages/toolcraft/dist/cli.d.ts

@@ -13,6 +13,7 @@ export interface CLIControls {
 export interface RunCLIOptions<TServices extends object = Record<string, unknown>> {
     apiVersion?: string;
     approvals?: boolean;
+    argv?: readonly string[];
     casing?: Casing;
     controls?: CLIControls;
     fetch?: typeof globalThis.fetch;

package/packages/toolcraft/dist/cli.js

@@ -3189,15 +3189,16 @@ function configureCommanderSuggestionOutput(command) {
 }
 export async function runCLI(roots, options = {}) {
     enableSourceMaps();
-    const normalizedRoot = normalizeRoots(roots, process.argv);
+    const argv = [...(options.argv ?? process.argv)];
+    const normalizedRoot = normalizeRoots(roots, argv);
     const root = options.approvals === true ? mergeApprovalsGroup(normalizedRoot) : normalizedRoot;
     await resolveMcpProxies(root, { projectRoot: options.projectRoot });
     const casing = options.casing ?? "kebab";
     const services = (options.services ?? {});
     const runtimeOptions = options.humanInLoop ?? {};
     const runtimeFetch = options.fetch ?? globalThis.fetch;
-    const version = options.version ?? findEntrypointPackageMetadata(process.argv[1])?.version;
-    const rootUsageName = options.rootUsageName ?? inferProgramName(process.argv);
+    const version = options.version ?? findEntrypointPackageMetadata(argv[1])?.version;
+    const rootUsageName = options.rootUsageName ?? inferProgramName(argv);
     const controls = resolveCLIControls(options.controls);
     const servicesWithBuiltIns = {
         ...services,
@@ -3208,8 +3209,8 @@ export async function runCLI(roots, options = {}) {
         apiVersion: options.apiVersion
     };
     validateServices(services);
-    if (hasHelpFlag(process.argv)) {
-        await renderGeneratedHelp(root, process.argv, { ...options, version });
+    if (hasHelpFlag(argv)) {
+        await renderGeneratedHelp(root, argv, { ...options, version });
         return;
     }
     const program = new CommanderCommand();
@@ -3250,7 +3251,7 @@ export async function runCLI(roots, options = {}) {
         addCommanderChild(program, command, isDefaultChild, rootChildNames);
     }
     configureCommanderSuggestionOutput(program);
-    const unknownCommand = findUnknownCommanderCommand(program, process.argv);
+    const unknownCommand = findUnknownCommanderCommand(program, argv);
     if (unknownCommand !== undefined) {
         createLogger().error(appendUsagePointer(formatUnknownCommandMessage(unknownCommand.input, unknownCommand.currentCommand), {
             rootUsageName,
@@ -3260,7 +3261,7 @@ export async function runCLI(roots, options = {}) {
         return;
     }
     try {
-        await program.parseAsync(process.argv);
+        await program.parseAsync(argv);
     }
     catch (error) {
         if (error instanceof ApprovalDeclinedError) {
@@ -3269,7 +3270,7 @@ export async function runCLI(roots, options = {}) {
         }
         const resolvedFlags = lastActionCommand ? getResolvedFlags(lastActionCommand) : undefined;
         const report = await writeErrorReport({
-            argv: process.argv,
+            argv,
             command: errorReportContext?.command,
             commandPath: errorReportContext?.commandPath ?? resolvedCommandPath,
             env: process.env,
@@ -3286,13 +3287,13 @@ export async function runCLI(roots, options = {}) {
         await handleRunError(error, {
             debugStackMode: resolvedFlags !== undefined
                 ? resolveDebugStackMode(resolvedFlags.debug)
-                : getDebugStackModeFromArgv(process.argv),
+                : getDebugStackModeFromArgv(argv),
             output: resolvedFlags !== undefined
                 ? resolveOutput(resolvedFlags)
-                : resolveOutputFromArgv(process.argv),
-            verbose: resolvedFlags ? Boolean(resolvedFlags.verbose) : process.argv.includes("--verbose"),
+                : resolveOutputFromArgv(argv),
+            verbose: resolvedFlags ? Boolean(resolvedFlags.verbose) : argv.includes("--verbose"),
             program,
-            argv: process.argv,
+            argv,
             rootUsageName,
             commandPath: resolvedCommandPath,
             userErrorPattern: errorReportContext?.params === undefined ? "usage" : "runtime-user"

package/packages/toolcraft-openapi/dist/bin/generate.d.ts

@@ -38,6 +38,7 @@ interface GenerateCliOptions {
     diff: boolean;
     input: string;
     inspect: boolean;
+    lockPath: string;
     outputFormat: OutputFormat;
     outputDir: string;
 }

package/packages/toolcraft-openapi/dist/bin/generate.js

@@ -19,6 +19,7 @@ const DEFAULT_OPTIONS = {
     diff: false,
     input: "openapi.json",
     inspect: false,
+    lockPath: "openapi.lock",
     outputFormat: "terminal",
     outputDir: "src/generated"
 };
@@ -27,6 +28,7 @@ const HELP_TEXT = `Usage: toolcraft-openapi-generate [options]
 Options:
   --input <path-or-url>  OpenAPI document to read (default: openapi.json)
   --output <dir>         Directory for generated command files (default: src/generated)
+  --lock <path>          Lock file path (default: openapi.lock)
   --check                Exit non-zero if generated output would change
   --diff                 Print a diff of generated changes without writing files
   --inspect              Inspect route compatibility without writing files
@@ -113,18 +115,27 @@ export async function syncGeneratedClient(options, services) {
     const effectiveConfig = hasErrorDiagnostics(diagnostics) ? undefined : configResult.config;
     const generatedFiles = generate(document, { specSha, config: effectiveConfig });
     const outputDir = path.resolve(services.cwd, options.outputDir);
+    const lockPath = path.resolve(services.cwd, options.lockPath);
+    const currentLockContents = await readOpenApiLockText(services.fs, lockPath);
+    const desiredLockContents = stringifyOpenApiLock({ specSha });
     const currentFiles = await readGeneratedFiles(services.fs, outputDir);
     const desiredFiles = new Map([
         ...generatedFiles.map((file) => [path.resolve(outputDir, file.path), file.contents]),
         ...createDownloadedSpecFiles(options.input, sourceText).map((file) => [path.resolve(outputDir, file.path), file.contents])
     ]);
     const updatedFiles = collectUpdatedFiles(currentFiles, desiredFiles);
+    const updatedLockFile = currentLockContents === desiredLockContents
+        ? undefined
+        : { path: lockPath, contents: desiredLockContents, previousContents: currentLockContents };
     const deletedFiles = collectDeletedFiles(currentFiles, desiredFiles);
-    const drifted = updatedFiles.length > 0 || deletedFiles.length > 0;
+    const drifted = updatedFiles.length > 0 || updatedLockFile !== undefined || deletedFiles.length > 0;
     if (!options.check && !options.diff && drifted && !hasErrorDiagnostics(diagnostics)) {
         try {
             await writeGeneratedFiles(services.fs, outputDir, updatedFiles);
             await deleteGeneratedFiles(services.fs, outputDir, deletedFiles);
+            if (updatedLockFile !== undefined) {
+                await writeOpenApiLock(services.fs, lockPath, { specSha });
+            }
         }
         catch (error) {
             await restoreGeneratedFiles(services.fs, outputDir, currentFiles, updatedFiles, deletedFiles);
@@ -137,8 +148,8 @@ export async function syncGeneratedClient(options, services) {
         diagnostics,
         drifted,
         specSha,
-        updatedFiles,
-        updatedFileCount: updatedFiles.length
+        updatedFiles: updatedLockFile === undefined ? updatedFiles : [...updatedFiles, updatedLockFile],
+        updatedFileCount: updatedFiles.length + (updatedLockFile === undefined ? 0 : 1)
     };
 }
 async function readAdjacentToolcraftConfig(input, services) {
@@ -243,7 +254,10 @@ function parseGenerateCliArgs(argv) {
             options.inspect = true;
             continue;
         }
-        if (argument === "--input" || argument === "--output" || argument === "--output-format") {
+        if (argument === "--input" ||
+            argument === "--output" ||
+            argument === "--lock" ||
+            argument === "--output-format") {
             const value = argv[index + 1];
             if (value === undefined) {
                 throw new UserError(`Missing value for ${JSON.stringify(argument)}.`);
@@ -260,6 +274,10 @@ function parseGenerateCliArgs(argv) {
             assignOptionValue(options, "--output", argument.slice("--output=".length));
             continue;
         }
+        if (argument.startsWith("--lock=")) {
+            assignOptionValue(options, "--lock", argument.slice("--lock=".length));
+            continue;
+        }
         if (argument.startsWith("--output-format=")) {
             assignOptionValue(options, "--output-format", argument.slice("--output-format=".length));
             continue;
@@ -283,8 +301,57 @@ function assignOptionValue(options, argument, value) {
         options.outputFormat = value;
         return;
     }
+    if (argument === "--lock") {
+        options.lockPath = value;
+        return;
+    }
     options.outputDir = value;
 }
+async function readOpenApiLockText(fs, lockPath) {
+    try {
+        const contents = await fs.readFile(lockPath, "utf8");
+        parseOpenApiLock(contents, lockPath);
+        return contents;
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function parseOpenApiLock(contents, lockPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch (error) {
+        throw new UserError(`Lock file ${JSON.stringify(lockPath)} is not valid JSON: ${getErrorMessage(error)}.`, { cause: error });
+    }
+    if (typeof parsed !== "object" ||
+        parsed === null ||
+        !("version" in parsed) ||
+        parsed.version !== 1 ||
+        !("specSha" in parsed) ||
+        typeof parsed.specSha !== "string" ||
+        parsed.specSha.length === 0) {
+        return null;
+    }
+    return { specSha: parsed.specSha };
+}
+function stringifyOpenApiLock(lock) {
+    return `${JSON.stringify({ version: 1, specSha: lock.specSha }, null, 2)}\n`;
+}
+async function writeOpenApiLock(fs, lockPath, lock) {
+    await fs.mkdir(path.dirname(lockPath), { recursive: true });
+    try {
+        await fs.writeFile(lockPath, stringifyOpenApiLock(lock), "utf8");
+    }
+    catch (error) {
+        const code = getErrorCode(error);
+        throw new UserError(`Failed to write lock file ${JSON.stringify(lockPath)}${code === undefined ? "" : ` (${code})`}: ${getErrorMessage(error)}`, { cause: error });
+    }
+}
 function createSpecSha(sourceText) {
     return `sha256:${createHash("sha256").update(sourceText).digest("hex")}`;
 }
@@ -446,6 +513,15 @@ function isNotFoundError(error) {
 function isAlreadyExistsError(error) {
     return hasOwnErrorCode(error, "EEXIST");
 }
+function getErrorCode(error) {
+    if (typeof error !== "object" || error === null || !("code" in error)) {
+        return undefined;
+    }
+    return typeof error.code === "string" ? error.code : undefined;
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function isDirectExecution(moduleUrl, argv) {
     const entryPoint = argv[1];
     if (entryPoint === undefined) {