open-azdo 0.1.0 → 0.1.2

package/README.md

@@ -19,7 +19,7 @@ The CLI consumes the Azure Pipeline checkout workspace directly and uses the bui
 Use Bun 1.3.10 or newer.
 
 ```bash
-bunx open-azdo review --model "openai/gpt-5.4"
+bun x open-azdo review --model "openai/gpt-5.4"
 ```
 
 Required inputs:
@@ -56,6 +56,7 @@ Exit behavior:
 ## Azure Pipelines
 
 The canonical example is in [examples/azure-pipelines.review.yml](/home/ponbac/dev/open-azdo/examples/azure-pipelines.review.yml).
+For first-time rollout or debugging, use [examples/azure-pipelines.review.debug.yml](/home/ponbac/dev/open-azdo/examples/azure-pipelines.review.debug.yml).
 
 Key requirements:
 
@@ -90,7 +91,7 @@ steps:
       tar -xzf opencode.tar.gz -C opencode-bin
       export PATH="$PWD/opencode-bin:$PATH"
 
-      bunx open-azdo review --model "$(OpenCodeModel)"
+      bun x open-azdo review --model "$(OpenCodeModel)"
     displayName: Review Pull Request
     env:
       SYSTEM_ACCESSTOKEN: $(System.AccessToken)

package/dist/open-azdo.js

@@ -1674,6 +1674,7 @@ var keys = (self) => Object.keys(self);
 var Array3 = globalThis.Array;
 var allocate = (n) => new Array3(n);
 var fromIterable2 = (collection) => Array3.isArray(collection) ? collection : Array3.from(collection);
+var ensure = (self) => Array3.isArray(self) ? self : [self];
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
 var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable2(self).concat(fromIterable2(that)));
 var isArray = Array3.isArray;
@@ -4687,6 +4688,18 @@ var formatLogSpan = (self, now) => {
   const label = formatLabel(self[0]);
   return `${label}=${now - self[1]}ms`;
 };
+var structuredMessage = (u) => {
+  switch (typeof u) {
+    case "bigint":
+    case "function":
+    case "symbol": {
+      return String(u);
+    }
+    default: {
+      return toJson(u);
+    }
+  }
+};
 var logWithLevel = (level) => (...message) => {
   let cause = undefined;
   for (let i = 0, len = message.length;i < len; i++) {
@@ -25751,10 +25764,10 @@ var toCodecEnsureArray = /* @__PURE__ */ toCodec((ast) => {
   }
   const out = onSerializerEnsureArray(ast);
   if (isArrays(out)) {
-    const ensure = new Union([out, decodeTo(string2, out, new Transformation(split(), passthrough2()))], "anyOf", {
+    const ensure2 = new Union([out, decodeTo(string2, out, new Transformation(split(), passthrough2()))], "anyOf", {
       [SERIALIZER_ENSURE_ARRAY]: true
     });
-    return isOptional(ast) ? optionalKey(ensure) : ensure;
+    return isOptional(ast) ? optionalKey(ensure2) : ensure2;
   }
   return out;
 });
@@ -28099,13 +28112,82 @@ var splitByWhitespaces = (template, rawTemplate) => {
 };
 var concatTokens = (prevTokens, nextTokens, isSeparated) => isSeparated || prevTokens.length === 0 || nextTokens.length === 0 ? [...prevTokens, ...nextTokens] : [...prevTokens.slice(0, -1), `${prevTokens.at(-1)}${nextTokens.at(0)}`, ...nextTokens.slice(1)];
 
+// src/logging.ts
+var REDACTED = "<redacted>";
+var DEFAULT_PREVIEW_LENGTH = 400;
+var sanitizeForLog = (value3) => {
+  if (exports_Redacted.isRedacted(value3)) {
+    return REDACTED;
+  }
+  if (value3 instanceof Error) {
+    return {
+      name: value3.name,
+      message: value3.message
+    };
+  }
+  if (Array.isArray(value3)) {
+    return value3.map(sanitizeForLog);
+  }
+  if (value3 && typeof value3 === "object") {
+    return Object.fromEntries(Object.entries(value3).map(([key, nested]) => [
+      key,
+      key.toLowerCase().includes("token") || key.toLowerCase().includes("secret") ? REDACTED : sanitizeForLog(nested)
+    ]));
+  }
+  return value3;
+};
+var truncateForLog = (value3, maxLength = DEFAULT_PREVIEW_LENGTH) => {
+  if (value3.length <= maxLength) {
+    return value3;
+  }
+  return `${value3.slice(0, maxLength)}... [truncated ${value3.length - maxLength} chars]`;
+};
+var withSanitizedAnnotations = (effect2, fields) => {
+  if (!fields || Object.keys(fields).length === 0) {
+    return effect2;
+  }
+  return effect2.pipe(exports_Effect.annotateLogs(sanitizeForLog(fields)));
+};
+var withLogAnnotations = (fields) => (effect2) => {
+  if (!fields || Object.keys(fields).length === 0) {
+    return effect2;
+  }
+  return effect2.pipe(exports_Effect.annotateLogs(sanitizeForLog(fields)));
+};
+var logInfo2 = (message, fields) => withSanitizedAnnotations(exports_Effect.logInfo(message), fields);
+var logError2 = (message, fields) => withSanitizedAnnotations(exports_Effect.logError(message), fields);
+
 // src/process.ts
 var DEFAULT_TIMEOUT_MS = 30000;
 var DEFAULT_MAX_OUTPUT_BYTES = 1e6;
-var commandLabel = (input) => [input.command, ...input.args].join(" ");
+var summarizeArg = (arg) => {
+  if (arg.includes(`
+`) || arg.length > 160) {
+    return `[${arg.length} chars omitted]`;
+  }
+  return truncateForLog(arg, 160);
+};
+var summarizeArgs = (args2) => args2.map(summarizeArg);
+var commandLabel = (input) => [input.command, ...summarizeArgs(input.args)].join(" ");
+var commandLogFields = (input, timeoutMs, maxOutputBytes) => ({
+  operation: input.operation,
+  command: input.command,
+  args: summarizeArgs(input.args),
+  cwd: input.cwd ?? "",
+  timeoutMs,
+  maxOutputBytes,
+  allowNonZeroExit: input.allowNonZeroExit ?? false,
+  stdinBytes: input.stdin?.length ?? 0
+});
+var commandResultLogFields = (input, timeoutMs, maxOutputBytes, result3) => ({
+  ...commandLogFields(input, timeoutMs, maxOutputBytes),
+  exitCode: result3.exitCode,
+  stdoutBytes: result3.stdout.length,
+  stderrBytes: result3.stderr.length
+});
 var toCommandExecutionError = (input, detail, stderr = "", exitCode = -1) => new CommandExecutionError({
   operation: input.operation,
-  command: [input.command, ...input.args],
+  command: [input.command, ...summarizeArgs(input.args)],
   cwd: input.cwd ?? "",
   detail,
   stderr,
@@ -28133,6 +28215,7 @@ class ProcessRunner extends Service()("open-azdo/ProcessRunner") {
       const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
       const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
       const encodedStdin = input.stdin === undefined ? "ignore" : fromIterable8([new TextEncoder().encode(input.stdin)]);
+      yield* logInfo2("Starting command.", commandLogFields(input, timeoutMs, maxOutputBytes));
       const command = make28(input.command, [...input.args], {
         ...input.cwd ? { cwd: input.cwd } : {},
         ...input.env ? { env: input.env, extendEnv: false } : {},
@@ -28148,7 +28231,7 @@ class ProcessRunner extends Service()("open-azdo/ProcessRunner") {
           handle.exitCode.pipe(exports_Effect.map((value3) => Number(value3)), exports_Effect.mapError(() => toCommandExecutionError(input, `Failed to read exit code for ${commandLabel(input)}.`)))
         ], { concurrency: "unbounded" });
         if (exitCode !== 0 && !input.allowNonZeroExit) {
-          return yield* toCommandExecutionError(input, stderr.trim().length > 0 ? `${commandLabel(input)} failed: ${stderr.trim()}` : `${commandLabel(input)} failed.`, stderr, exitCode);
+          return yield* toCommandExecutionError(input, stderr.trim().length > 0 ? `${commandLabel(input)} failed: ${truncateForLog(stderr.trim())}` : `${commandLabel(input)} failed.`, stderr, exitCode);
         }
         return {
           exitCode,
@@ -28158,7 +28241,12 @@ class ProcessRunner extends Service()("open-azdo/ProcessRunner") {
       }).pipe(exports_Effect.scoped, exports_Effect.timeoutOption(timeoutMs), exports_Effect.flatMap((maybeResult) => exports_Option.match(maybeResult, {
         onNone: () => exports_Effect.fail(toCommandExecutionError(input, `${commandLabel(input)} timed out after ${timeoutMs}ms.`)),
         onSome: exports_Effect.succeed
-      })));
+      })), exports_Effect.tap((result3) => logInfo2("Command completed.", commandResultLogFields(input, timeoutMs, maxOutputBytes, result3))), exports_Effect.tapError((error) => logError2("Command failed.", {
+        ...commandLogFields(input, timeoutMs, maxOutputBytes),
+        detail: error.detail,
+        exitCode: error.exitCode,
+        stderrPreview: truncateForLog(error.stderr || error.detail)
+      })), exports_Effect.withLogSpan(input.operation));
     });
     return ProcessRunner.of({
       execute
@@ -28342,46 +28430,6 @@ var runGit = exports_Effect.fn("git.runGit")(function* (cwd, args2, allowFailure
   return yield* git.runGit(cwd, args2, allowFailure);
 });
 
-// src/logging.ts
-var REDACTED = "<redacted>";
-var sanitizeForLog = (value3) => {
-  if (exports_Redacted.isRedacted(value3)) {
-    return REDACTED;
-  }
-  if (value3 instanceof Error) {
-    return {
-      name: value3.name,
-      message: value3.message
-    };
-  }
-  if (Array.isArray(value3)) {
-    return value3.map(sanitizeForLog);
-  }
-  if (value3 && typeof value3 === "object") {
-    return Object.fromEntries(Object.entries(value3).map(([key, nested]) => [
-      key,
-      key.toLowerCase().includes("token") || key.toLowerCase().includes("secret") ? REDACTED : sanitizeForLog(nested)
-    ]));
-  }
-  return value3;
-};
-var renderLogLine = (level, message, fields) => {
-  const sanitizedFields = sanitizeForLog(fields ?? {});
-  return JSON.stringify({
-    level,
-    message,
-    ...sanitizedFields
-  });
-};
-var writeLogLine = exports_Effect.fn("logging.writeLogLine")(function* (streamName, line) {
-  const stdio = yield* Stdio2;
-  const sink = streamName === "stdout" ? stdio.stdout() : stdio.stderr();
-  yield* make24(`${line}
-`).pipe(run2(sink));
-});
-var writeInfoLog = (message, fields) => writeLogLine("stdout", renderLogLine("info", message, fields));
-var writeErrorLog = (message, fields) => writeLogLine("stderr", renderLogLine("error", message, fields));
-
 // src/opencode.ts
 var buildOpenCodeConfig = (agentName) => ({
   $schema: "https://opencode.ai/config.json",
@@ -28473,6 +28521,12 @@ class OpenCodeService extends Service()("open-azdo/OpenCodeService") {
     const runtimeInput = yield* RuntimeInput;
     const run3 = exports_Effect.fn("OpenCodeService.run")(function* (config, prompt) {
       return yield* exports_Effect.gen(function* () {
+        yield* logInfo2("Preparing OpenCode execution.", {
+          agent: config.agent,
+          model: config.model,
+          workspace: config.workspace,
+          promptChars: prompt.length
+        });
         const tempDir = yield* fileSystem.makeTempDirectoryScoped({
           prefix: "open-azdo-opencode-"
         }).pipe(exports_Effect.mapError((error) => new OpenCodeOutputError({
@@ -28488,6 +28542,11 @@ class OpenCodeService extends Service()("open-azdo/OpenCodeService") {
           message: "Failed to write temporary OpenCode configuration.",
           output: String(error)
         })));
+        yield* logInfo2("Prepared temporary OpenCode files.", {
+          tempDir,
+          configPath,
+          promptPath
+        });
         const result3 = yield* runner.execute({
           operation: "OpenCodeService.run",
           command: "opencode",
@@ -28504,20 +28563,34 @@ class OpenCodeService extends Service()("open-azdo/OpenCodeService") {
           stderr: error.stderr,
           exitCode: error.exitCode
         })));
+        yield* logInfo2("OpenCode process exited.", {
+          exitCode: result3.exitCode,
+          stdoutBytes: result3.stdout.length,
+          stderrBytes: result3.stderr.length
+        });
         if (result3.exitCode !== 0) {
+          yield* logError2("OpenCode exited with a non-zero status.", {
+            exitCode: result3.exitCode,
+            stderrPreview: truncateForLog(result3.stderr)
+          });
           return yield* new OpenCodeInvocationError({
             message: "OpenCode exited with a non-zero status.",
             stderr: result3.stderr,
             exitCode: result3.exitCode
           });
         }
-        return yield* exports_Effect.try({
+        const response = yield* exports_Effect.try({
           try: () => extractFinalResponse(result3.stdout),
           catch: (error) => error instanceof OpenCodeOutputError ? error : new OpenCodeOutputError({
             message: "OpenCode did not return a valid final response.",
             output: String(error)
           })
         });
+        yield* logInfo2("Extracted final OpenCode response.", {
+          responseChars: response.length,
+          responsePreview: truncateForLog(response)
+        });
+        return response;
       }).pipe(exports_Effect.scoped);
     });
     return OpenCodeService.of({
@@ -28592,58 +28665,88 @@ var writeStdout = exports_Effect.fn("cli.writeStdout")(function* (text) {
   const stdio = yield* Stdio2;
   yield* make24(text).pipe(run2(stdio.stdout()));
 });
+var reviewLogFields = (config) => ({
+  command: config.command,
+  model: config.model,
+  workspace: config.workspace,
+  organization: config.organization,
+  project: config.project,
+  repositoryId: config.repositoryId,
+  pullRequestId: config.pullRequestId,
+  collectionUrl: config.collectionUrl,
+  agent: config.agent,
+  dryRun: config.dryRun,
+  json: config.json
+});
 var runReviewWithConfig = exports_Effect.fn("cli.runReviewWithConfig")(function* (config) {
-  const azureContext = createAzureContext(config);
-  yield* writeInfoLog("Resolved review configuration.", {
-    command: config.command,
-    model: config.model,
-    workspace: config.workspace,
-    organization: config.organization,
-    project: config.project,
-    repositoryId: config.repositoryId,
-    pullRequestId: config.pullRequestId,
-    collectionUrl: config.collectionUrl,
-    agent: config.agent,
-    dryRun: config.dryRun,
-    json: config.json,
-    systemAccessToken: config.systemAccessToken
-  });
-  const [metadata, gitDiff] = yield* exports_Effect.all([
-    getPullRequestMetadata(azureContext, config.systemAccessToken),
-    resolveGitDiff(config)
-  ]);
-  const reviewContext = yield* buildReviewContext(config.workspace, metadata, gitDiff);
-  const prompt = yield* buildReviewPrompt(config, reviewContext);
-  const rawResult = yield* runOpenCode(config, prompt);
-  const decodedJson = yield* exports_Effect.try({
-    try: () => parseJsonString(rawResult),
-    catch: () => ({ summary: rawResult, verdict: "concerns", findings: [], unmappedNotes: [] })
-  });
-  const reviewResult = yield* decodeReviewResult(decodedJson, gitDiff.changedLinesByFile);
-  const publishResult = yield* publishReview(config, reviewResult);
-  if (config.json) {
-    yield* writeStdout(`${stringifyJson2({
-      status: "ok",
+  return yield* exports_Effect.gen(function* () {
+    const azureContext = createAzureContext(config);
+    yield* logInfo2("Resolved review configuration.");
+    yield* logInfo2("Loading pull request metadata and git diff.");
+    const [metadata, gitDiff] = yield* exports_Effect.all([
+      getPullRequestMetadata(azureContext, config.systemAccessToken),
+      resolveGitDiff(config)
+    ]);
+    yield* logInfo2("Loaded review inputs.", {
+      pullRequestTitle: metadata.title,
+      changedFiles: gitDiff.changedFiles.length,
+      diffBytes: gitDiff.diffText.length,
+      baseRef: gitDiff.baseRef,
+      headRef: gitDiff.headRef
+    });
+    const reviewContext = yield* buildReviewContext(config.workspace, metadata, gitDiff);
+    yield* logInfo2("Built review context.", {
+      changedFiles: reviewContext.changedFiles.length
+    });
+    const prompt = yield* buildReviewPrompt(config, reviewContext);
+    yield* logInfo2("Built review prompt.", {
+      promptChars: prompt.length
+    });
+    const rawResult = yield* runOpenCode(config, prompt);
+    yield* logInfo2("Received OpenCode response.", {
+      responseChars: rawResult.length
+    });
+    const decodedJson = yield* exports_Effect.try({
+      try: () => parseJsonString(rawResult),
+      catch: () => ({ summary: rawResult, verdict: "concerns", findings: [], unmappedNotes: [] })
+    });
+    const reviewResult = yield* decodeReviewResult(decodedJson, gitDiff.changedLinesByFile);
+    yield* logInfo2("Decoded review result.", {
       verdict: reviewResult.verdict,
       findings: reviewResult.findings.length,
       inlineFindings: reviewResult.inlineFindings.length,
-      unmappedNotes: reviewResult.unmappedNotes.length,
-      dryRun: config.dryRun,
-      actions: publishResult.actions.length
-    })}
+      summaryOnlyFindings: reviewResult.summaryOnlyFindings.length,
+      unmappedNotes: reviewResult.unmappedNotes.length
+    });
+    const publishResult = yield* publishReview(config, reviewResult);
+    yield* logInfo2("Published review result.", {
+      actions: publishResult.actions.length,
+      dryRun: config.dryRun
+    });
+    if (config.json) {
+      yield* writeStdout(`${stringifyJson2({
+        status: "ok",
+        verdict: reviewResult.verdict,
+        findings: reviewResult.findings.length,
+        inlineFindings: reviewResult.inlineFindings.length,
+        unmappedNotes: reviewResult.unmappedNotes.length,
+        dryRun: config.dryRun,
+        actions: publishResult.actions.length
+      })}
 `);
-  } else if (config.dryRun) {
-    yield* writeStdout(`${buildSummaryComment(reviewResult)}
+    } else if (config.dryRun) {
+      yield* writeStdout(`${buildSummaryComment(reviewResult)}
 `);
-  } else {
-    yield* writeStdout(`Posted review verdict ${reviewResult.verdict} with ${reviewResult.findings.length} findings.
+    } else {
+      yield* writeStdout(`Posted review verdict ${reviewResult.verdict} with ${reviewResult.findings.length} findings.
 `);
-  }
-  return 0;
+    }
+    return 0;
+  }).pipe(withLogAnnotations(reviewLogFields(config)));
 });
 var runCli = exports_Effect.fn("cli.runCli")(function* () {
   const config = yield* ReviewConfigValue;
-  return yield* runReviewWithConfig(config);
+  return yield* runReviewWithConfig(config).pipe(exports_Effect.withLogSpan("open-azdo.review"));
 });
 var runCliWithExitHandling = exports_Effect.fn("cli.runCliWithExitHandling")(function* () {
   const exit3 = yield* exports_Effect.exit(runCli());
@@ -28657,7 +28760,7 @@ var runCliWithExitHandling = exports_Effect.fn("cli.runCliWithExitHandling")(fun
   if (exports_Exit.isSuccess(configExit)) {
     yield* publishFailureSummary(configExit.value, failureReason).pipe(exports_Effect.ignore);
   }
-  yield* writeErrorLog("open-azdo failed.", {
+  yield* logError2("open-azdo failed.", {
     cause: failureReason
   });
   return 1;
@@ -29762,6 +29865,53 @@ var layer9 = layer8;
 
 // node_modules/@effect/platform-bun/dist/BunServices.js
 var layer10 = /* @__PURE__ */ layer.pipe(/* @__PURE__ */ provideMerge(/* @__PURE__ */ mergeAll2(layer3, layer5, layer7, layer9)));
+// node_modules/effect/dist/Logger.js
+var CurrentLoggers2 = CurrentLoggers;
+var map14 = /* @__PURE__ */ dual(2, (self, f) => loggerMake((options) => f(self.log(options))));
+var withConsoleLog = (self) => loggerMake((options) => {
+  const console2 = options.fiber.getRef(ConsoleRef);
+  return console2.log(self.log(options));
+});
+var formatFiberId = (fiberId3) => `#${fiberId3}`;
+var formatStructured = /* @__PURE__ */ loggerMake(({
+  cause,
+  date: date2,
+  fiber: fiber3,
+  logLevel,
+  message
+}) => {
+  const annotationsObj = {};
+  const spansObj = {};
+  const annotations2 = fiber3.getRef(CurrentLogAnnotations);
+  for (const [key, value3] of Object.entries(annotations2)) {
+    annotationsObj[key] = structuredMessage(value3);
+  }
+  const now2 = date2.getTime();
+  const spans = fiber3.getRef(CurrentLogSpans);
+  for (const [label, timestamp] of spans) {
+    spansObj[label] = now2 - timestamp;
+  }
+  const messageArr = ensure(message);
+  return {
+    message: messageArr.length === 1 ? structuredMessage(messageArr[0]) : messageArr.map(structuredMessage),
+    level: logLevel.toUpperCase(),
+    timestamp: date2.toISOString(),
+    cause: cause.reasons.length > 0 ? causePretty(cause) : undefined,
+    annotations: annotationsObj,
+    spans: spansObj,
+    fiberId: formatFiberId(fiber3.id)
+  };
+});
+var formatJson2 = /* @__PURE__ */ map14(formatStructured, formatJson);
+var consoleJson = /* @__PURE__ */ withConsoleLog(formatJson2);
+var layer11 = (loggers, options) => effect(CurrentLoggers2, withFiber(fnUntraced(function* (fiber3) {
+  const currentLoggers = new Set(options?.mergeWithExisting === true ? fiber3.getRef(CurrentLoggers) : []);
+  for (const logger of loggers) {
+    currentLoggers.add(isEffect(logger) ? yield* logger : logger);
+  }
+  return currentLoggers;
+})));
+
 // src/runtime.ts
 var makeAppLayer = (argv, env) => {
   const inputLayer = succeed5(RuntimeInput, {
@@ -29775,7 +29925,8 @@ var makeAppLayer = (argv, env) => {
   const gitLayer = GitService.layer.pipe(provide2(mergeAll2(processLayer, exports_BunServices.layer)));
   const openCodeLayer = OpenCodeService.layer.pipe(provide2(mergeAll2(processLayer, bunRuntimeLayer)));
   const azureDevOpsLayer = AzureDevOpsService.layer.pipe(provide2(fetchLayer));
-  return mergeAll2(bunRuntimeLayer, fetchLayer, configLayer, processLayer, gitLayer, openCodeLayer, azureDevOpsLayer);
+  const loggerLayer = layer11([consoleJson]);
+  return mergeAll2(bunRuntimeLayer, fetchLayer, configLayer, processLayer, gitLayer, openCodeLayer, azureDevOpsLayer, loggerLayer);
 };
 
 // src/main.ts
@@ -29784,4 +29935,4 @@ var main = async (argv, env) => await exports_Effect.runPromise(runCliWithExitHa
 // bin/open-azdo.ts
 process.exitCode = await main(process.argv.slice(2), process.env);
 
-//# debugId=72684AFC268FCFAF64756E2164756E21
+//# debugId=3D47738376EA848764756E2164756E21