/** * ClaudeTextGeneration – Text generation layer using the Claude CLI. * * Implements the same TextGenerationShape contract as CodexTextGeneration but * delegates to the `claude` CLI (`claude -p`) with structured JSON output * instead of the `codex exec` CLI. * * @module ClaudeTextGeneration */import * as Effect from "effect/Effect";import * as Option from "effect/Option";import * as Schema from "effect/Schema";import * as Stream from "effect/Stream";import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"; import { type ClaudeSettings, type ModelSelection } from "@t3tools/contracts";import { sanitizeBranchFragment, sanitizeFeatureBranchName } from "@t3tools/shared/git"; import { TextGenerationError } from "@t3tools/contracts";import { type TextGenerationShape } from "./TextGeneration.ts";import {  buildBranchNamePrompt,  buildCommitMessagePrompt,  buildPrContentPrompt,  buildThreadTitlePrompt,} from "./TextGenerationPrompts.ts";import {  normalizeCliError,  sanitizeCommitSubject,  sanitizePrTitle,  sanitizeThreadTitle,  toJsonSchemaObject,} from "./TextGenerationUtils.ts";import {  getModelSelectionStringOptionValue,  getProviderOptionDescriptors,} from "@t3tools/shared/model";import {  getClaudeModelCapabilities,  isClaudeUltracodeEffort,  normalizeClaudeCliEffort,  resolveClaudeApiModelId,  resolveClaudeEffort,} from "../provider/Layers/ClaudeProvider.ts";import { makeClaudeEnvironment } from "../provider/Drivers/ClaudeHome.ts"; const CLAUDE_TIMEOUT_MS = 180_000; /** * Schema for the wrapper JSON returned by `claude -p --output-format json`. * We only care about `structured_output`. */const ClaudeOutputEnvelope = Schema.Struct({  structured_output: Schema.Unknown,}); const encodeJsonString = Schema.encodeEffect(Schema.UnknownFromJsonString);const decodeClaudeOutputEnvelope = Schema.decodeEffect(Schema.fromJsonString(ClaudeOutputEnvelope)); export const makeClaudeTextGeneration = Effect.fn("makeClaudeTextGeneration")(function* (  claudeSettings: ClaudeSettings,  environment: NodeJS.ProcessEnv = process.env,) {  const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;  const claudeEnvironment = yield* makeClaudeEnvironment(claudeSettings, environment);   const readStreamAsString = <E>(    operation: string,    stream: Stream.Stream<Uint8Array, E>,  ): Effect.Effect<string, TextGenerationError> =>    stream.pipe(      Stream.decodeText(),      Stream.runFold(        () => "",        (acc, chunk) => acc + chunk,      ),      Effect.mapError((cause) =>        normalizeCliError("claude", operation, cause, "Failed to collect process output"),      ),    );   const encodeJsonForOperation = (    operation:      | "generateCommitMessage"      | "generatePrContent"      | "generateBranchName"      | "generateThreadTitle",    value: unknown,    detail: string,  ): Effect.Effect<string, TextGenerationError> =>    encodeJsonString(value).pipe(      Effect.mapError(        (cause) =>          new TextGenerationError({            operation,            detail,            cause,          }),      ),    );   /**   * Spawn the Claude CLI with structured JSON output and return the parsed,   * schema-validated result.   */  const runClaudeJson = Effect.fn("runClaudeJson")(function* <S extends Schema.Top>({    operation,    cwd,    prompt,    outputSchemaJson,    modelSelection,  }: {    operation:      | "generateCommitMessage"      | "generatePrContent"      | "generateBranchName"      | "generateThreadTitle";    cwd: string;    prompt: string;    outputSchemaJson: S;    modelSelection: ModelSelection;  }): Effect.fn.Return<S["Type"], TextGenerationError, S["DecodingServices"]> {    const jsonSchemaStr = yield* encodeJsonForOperation(      operation,      toJsonSchemaObject(outputSchemaJson),      "Failed to encode structured output schema.",    );    const caps = getClaudeModelCapabilities(modelSelection.model);    const descriptors = getProviderOptionDescriptors({      caps,      selections: modelSelection.options,    });    const findDescriptor = (id: string) => descriptors.find((descriptor) => descriptor.id === id);    const rawEffortSelection = getModelSelectionStringOptionValue(modelSelection, "effort");    const resolvedEffort = resolveClaudeEffort(caps, rawEffortSelection);    const cliEffort = normalizeClaudeCliEffort(resolvedEffort, modelSelection.model);    const ultracode = isClaudeUltracodeEffort(resolvedEffort);    const thinkingDescriptor = findDescriptor("thinking");    const fastModeDescriptor = findDescriptor("fastMode");    const thinking =      thinkingDescriptor?.type === "boolean" ? thinkingDescriptor.currentValue : undefined;    const fastMode =      fastModeDescriptor?.type === "boolean" ? fastModeDescriptor.currentValue : undefined;    const settings = {      ...(typeof thinking === "boolean" ? { alwaysThinkingEnabled: thinking } : {}),      ...(fastMode ? { fastMode: true } : {}),      ...(ultracode ? { ultracode: true } : {}),    };    const settingsJson =      Object.keys(settings).length > 0        ? yield* encodeJsonForOperation(            operation,            settings,            "Failed to encode Claude CLI settings.",          )        : undefined;     const runClaudeCommand = Effect.fn("runClaudeJson.runClaudeCommand")(function* () {      const command = ChildProcess.make(        claudeSettings.binaryPath || "claude",        [          "-p",          "--output-format",          "json",          "--json-schema",          jsonSchemaStr,          "--model",          resolveClaudeApiModelId(modelSelection),          ...(cliEffort ? ["--effort", cliEffort] : []),          ...(settingsJson ? ["--settings", settingsJson] : []),          "--dangerously-skip-permissions",        ],        {          env: claudeEnvironment,          cwd,          shell: process.platform === "win32",          stdin: {            stream: Stream.encodeText(Stream.make(prompt)),          },        },      );       const child = yield* commandSpawner        .spawn(command)        .pipe(          Effect.mapError((cause) =>            normalizeCliError("claude", operation, cause, "Failed to spawn Claude CLI process"),          ),        );       const [stdout, stderr, exitCode] = yield* Effect.all(        [          readStreamAsString(operation, child.stdout),          readStreamAsString(operation, child.stderr),          child.exitCode.pipe(            Effect.mapError((cause) =>              normalizeCliError("claude", operation, cause, "Failed to read Claude CLI exit code"),            ),          ),        ],        { concurrency: "unbounded" },      );       if (exitCode !== 0) {        const stderrDetail = stderr.trim();        const stdoutDetail = stdout.trim();        const detail = stderrDetail.length > 0 ? stderrDetail : stdoutDetail;        return yield* new TextGenerationError({          operation,          detail:            detail.length > 0              ? `Claude CLI command failed: ${detail}`              : `Claude CLI command failed with code ${exitCode}.`,        });      }       return stdout;    });     const rawStdout = yield* runClaudeCommand().pipe(      Effect.scoped,      Effect.timeoutOption(CLAUDE_TIMEOUT_MS),      Effect.flatMap(        Option.match({          onNone: () =>            Effect.fail(              new TextGenerationError({ operation, detail: "Claude CLI request timed out." }),            ),          onSome: (value) => Effect.succeed(value),        }),      ),    );     const envelope = yield* decodeClaudeOutputEnvelope(rawStdout).pipe(      Effect.catchTag("SchemaError", (cause) =>        Effect.fail(          new TextGenerationError({            operation,            detail: "Claude CLI returned unexpected output format.",            cause,          }),        ),      ),    );     const decodeOutput = Schema.decodeEffect(outputSchemaJson);    return yield* decodeOutput(envelope.structured_output).pipe(      Effect.catchTag("SchemaError", (cause) =>        Effect.fail(          new TextGenerationError({            operation,            detail: "Claude returned invalid structured output.",            cause,          }),        ),      ),    );  });   // ---------------------------------------------------------------------------  // TextGenerationShape methods  // ---------------------------------------------------------------------------   const generateCommitMessage: TextGenerationShape["generateCommitMessage"] = Effect.fn(    "ClaudeTextGeneration.generateCommitMessage",  )(function* (input) {    const { prompt, outputSchema } = buildCommitMessagePrompt({      branch: input.branch,      stagedSummary: input.stagedSummary,      stagedPatch: input.stagedPatch,      includeBranch: input.includeBranch === true,    });     const generated = yield* runClaudeJson({      operation: "generateCommitMessage",      cwd: input.cwd,      prompt,      outputSchemaJson: outputSchema,      modelSelection: input.modelSelection,    });     return {      subject: sanitizeCommitSubject(generated.subject),      body: generated.body.trim(),      ...("branch" in generated && typeof generated.branch === "string"        ? { branch: sanitizeFeatureBranchName(generated.branch) }        : {}),    };  });   const generatePrContent: TextGenerationShape["generatePrContent"] = Effect.fn(    "ClaudeTextGeneration.generatePrContent",  )(function* (input) {    const { prompt, outputSchema } = buildPrContentPrompt({      baseBranch: input.baseBranch,      headBranch: input.headBranch,      commitSummary: input.commitSummary,      diffSummary: input.diffSummary,      diffPatch: input.diffPatch,    });     const generated = yield* runClaudeJson({      operation: "generatePrContent",      cwd: input.cwd,      prompt,      outputSchemaJson: outputSchema,      modelSelection: input.modelSelection,    });     return {      title: sanitizePrTitle(generated.title),      body: generated.body.trim(),    };  });   const generateBranchName: TextGenerationShape["generateBranchName"] = Effect.fn(    "ClaudeTextGeneration.generateBranchName",  )(function* (input) {    const { prompt, outputSchema } = buildBranchNamePrompt({      message: input.message,      attachments: input.attachments,    });     const generated = yield* runClaudeJson({      operation: "generateBranchName",      cwd: input.cwd,      prompt,      outputSchemaJson: outputSchema,      modelSelection: input.modelSelection,    });     return {      branch: sanitizeBranchFragment(generated.branch),    };  });   const generateThreadTitle: TextGenerationShape["generateThreadTitle"] = Effect.fn(    "ClaudeTextGeneration.generateThreadTitle",  )(function* (input) {    const { prompt, outputSchema } = buildThreadTitlePrompt({      message: input.message,      attachments: input.attachments,    });     const generated = yield* runClaudeJson({      operation: "generateThreadTitle",      cwd: input.cwd,      prompt,      outputSchemaJson: outputSchema,      modelSelection: input.modelSelection,    });     return {      title: sanitizeThreadTitle(generated.title),    };  });   return {    generateCommitMessage,    generatePrContent,    generateBranchName,    generateThreadTitle,  } satisfies TextGenerationShape;});