clanka 0.2.19 → 0.2.21

package/src/CodeChunker.ts

@@ -59,18 +59,21 @@ export class CodeChunker extends ServiceMap.Service<
       readonly path: string
       readonly chunkSize: number
       readonly chunkOverlap: number
+      readonly chunkMaxCharacters?: number | undefined
     }): Effect.Effect<ReadonlyArray<CodeChunk>>
     chunkFiles(options: {
       readonly root: string
       readonly paths: ReadonlyArray<string>
       readonly chunkSize: number
       readonly chunkOverlap: number
+      readonly chunkMaxCharacters?: number | undefined
     }): Stream.Stream<CodeChunk>
     chunkCodebase(options: {
       readonly root: string
       readonly maxFileSize?: string | undefined
       readonly chunkSize: number
       readonly chunkOverlap: number
+      readonly chunkMaxCharacters?: number | undefined
     }): Stream.Stream<CodeChunk>
   }
 >()("clanka/CodeChunker") {}
@@ -157,6 +160,7 @@ interface LineRange {
 interface ChunkSettings {
   readonly chunkSize: number
   readonly chunkOverlap: number
+  readonly chunkMaxCharacters: number
 }
 
 interface ChunkRange extends LineRange {
@@ -234,16 +238,23 @@ export const isMeaningfulFile = (path: string): boolean => {
 const resolveChunkSettings = (options: {
   readonly chunkSize: number
   readonly chunkOverlap: number
+  readonly chunkMaxCharacters?: number | undefined
 }): ChunkSettings => {
   const chunkSize = Math.max(1, options.chunkSize)
   const chunkOverlap = Math.max(
     0,
     Math.min(chunkSize - 1, options.chunkOverlap),
   )
+  const chunkMaxCharacters =
+    options.chunkMaxCharacters !== undefined &&
+    Number.isFinite(options.chunkMaxCharacters)
+      ? Math.max(1, Math.floor(options.chunkMaxCharacters))
+      : Number.POSITIVE_INFINITY
 
   return {
     chunkSize,
     chunkOverlap,
+    chunkMaxCharacters,
   }
 }
 
@@ -345,24 +356,76 @@ const normalizeLineRange = (
   }
 }
 
+const lineLengthPrefixSums = (
+  lines: ReadonlyArray<string>,
+): ReadonlyArray<number> => {
+  const sums = [0] as Array<number>
+
+  for (let index = 0; index < lines.length; index++) {
+    sums.push(sums[index]! + lines[index]!.length)
+  }
+
+  return sums
+}
+
+const lineRangeCharacterLength = (
+  prefixSums: ReadonlyArray<number>,
+  range: LineRange,
+): number =>
+  prefixSums[range.endLine]! -
+  prefixSums[range.startLine - 1]! +
+  (range.endLine - range.startLine)
+
+const resolveSegmentEndLine = (options: {
+  readonly startLine: number
+  readonly maxEndLine: number
+  readonly settings: ChunkSettings
+  readonly prefixSums: ReadonlyArray<number>
+}): number => {
+  if (options.settings.chunkMaxCharacters === Number.POSITIVE_INFINITY) {
+    return options.maxEndLine
+  }
+
+  let endLine = options.maxEndLine
+  while (
+    endLine > options.startLine &&
+    lineRangeCharacterLength(options.prefixSums, {
+      startLine: options.startLine,
+      endLine,
+    }) > options.settings.chunkMaxCharacters
+  ) {
+    endLine--
+  }
+
+  return endLine
+}
+
 const splitRange = (
   range: LineRange,
   settings: ChunkSettings,
+  prefixSums: ReadonlyArray<number>,
 ): ReadonlyArray<LineRange> => {
   const lineCount = range.endLine - range.startLine + 1
-  if (lineCount <= settings.chunkSize) {
+  if (
+    lineCount <= settings.chunkSize &&
+    lineRangeCharacterLength(prefixSums, range) <= settings.chunkMaxCharacters
+  ) {
     return [range]
   }
-
-  const step = settings.chunkSize - settings.chunkOverlap
   const out = [] as Array<LineRange>
 
-  for (
-    let startLine = range.startLine;
-    startLine <= range.endLine;
-    startLine += step
-  ) {
-    const endLine = Math.min(range.endLine, startLine + settings.chunkSize - 1)
+  for (let startLine = range.startLine; startLine <= range.endLine; ) {
+    const maxEndLine = Math.min(
+      range.endLine,
+      startLine + settings.chunkSize - 1,
+    )
+    const endLine = resolveSegmentEndLine({
+      startLine,
+      maxEndLine,
+      settings,
+      prefixSums,
+    })
+
     out.push({
       startLine,
       endLine,
@@ -371,6 +434,8 @@ const splitRange = (
     if (endLine >= range.endLine) {
       break
     }
+
+    startLine = Math.max(startLine + 1, endLine - settings.chunkOverlap + 1)
   }
 
   return out
@@ -648,6 +713,7 @@ const chunksFromRanges = (
 
   const out = [] as Array<CodeChunk>
   const seen = new Set<string>()
+  const prefixSums = lineLengthPrefixSums(lines)
 
   for (const range of ranges) {
     const normalizedRange = normalizeLineRange(range, lines.length)
@@ -655,7 +721,7 @@ const chunksFromRanges = (
       continue
     }
 
-    const allSegments = splitRange(normalizedRange, settings)
+    const allSegments = splitRange(normalizedRange, settings, prefixSums)
     const segments =
       range.type === "class" &&
       allSegments.length > 1 &&
@@ -709,8 +775,8 @@ const chunkWithLineWindows = (
   lines: ReadonlyArray<string>,
   settings: ChunkSettings,
 ): ReadonlyArray<CodeChunk> => {
-  const step = settings.chunkSize - settings.chunkOverlap
   const out = [] as Array<CodeChunk>
+  const prefixSums = lineLengthPrefixSums(lines)
 
   for (let index = 0; index < lines.length; ) {
     if (!isMeaningfulLine(lines[index]!)) {
@@ -718,25 +784,38 @@ const chunkWithLineWindows = (
       continue
     }
 
-    const start = index
-    const end = Math.min(lines.length, start + settings.chunkSize)
-    const chunkLines = lines.slice(start, end)
+    const startLine = index + 1
+    const maxEndLine = Math.min(
+      lines.length,
+      startLine + settings.chunkSize - 1,
+    )
+    const endLine = resolveSegmentEndLine({
+      startLine,
+      maxEndLine,
+      settings,
+      prefixSums,
+    })
+    const chunkLines = lines.slice(startLine - 1, endLine)
 
     out.push({
       path,
-      startLine: start + 1,
-      endLine: end,
+      startLine,
+      endLine,
       name: undefined,
       type: undefined,
       parent: undefined,
       content: chunkLines.join("\n"),
     })
 
-    index += step
-
-    if (end >= lines.length) {
+    if (endLine >= lines.length) {
       break
     }
+
+    const nextStartLine = Math.max(
+      startLine + 1,
+      endLine - settings.chunkOverlap + 1,
+    )
+    index = nextStartLine - 1
   }
 
   return out
@@ -752,6 +831,7 @@ export const chunkFileContent = (
   options: {
     readonly chunkSize: number
     readonly chunkOverlap: number
+    readonly chunkMaxCharacters?: number | undefined
   },
 ): ReadonlyArray<CodeChunk> => {
   if (content.trim().length === 0 || isProbablyMinified(content)) {
@@ -869,6 +949,9 @@ export const layer: Layer.Layer<
                 path,
                 chunkSize: options.chunkSize,
                 chunkOverlap: options.chunkOverlap,
+                ...(options.chunkMaxCharacters === undefined
+                  ? {}
+                  : { chunkMaxCharacters: options.chunkMaxCharacters }),
               }),
               Stream.fromArrayEffect,
             ),
@@ -891,6 +974,9 @@ export const layer: Layer.Layer<
           paths: files,
           chunkSize: options.chunkSize,
           chunkOverlap: options.chunkOverlap,
+          ...(options.chunkMaxCharacters === undefined
+            ? {}
+            : { chunkMaxCharacters: options.chunkMaxCharacters }),
         })
       }, Stream.unwrap)
 

package/src/ScriptPreprocessing.test.ts

@@ -169,6 +169,7 @@ describe("preprocessScript", () => {
     "patch9",
     "patch10",
     "patch11",
+    "patch12",
   ])("fixes broken %s", (fixture) => {
     const content = readFileSync(
       join(__dirname, "fixtures", `${fixture}-broken.txt`),

package/src/ScriptPreprocessing.ts

@@ -316,6 +316,127 @@ const findClosingParen = (text: string, openParen: number): number => {
   return -1
 }
 
+const findClosingBrace = (text: string, openBrace: number): number => {
+  let depth = 1
+  let stringDelimiter: '"' | "'" | "`" | undefined
+
+  for (let i = openBrace + 1; i < text.length; i++) {
+    const char = text[i]!
+
+    if (stringDelimiter !== undefined) {
+      if (char === stringDelimiter && !isEscaped(text, i)) {
+        stringDelimiter = undefined
+      }
+      continue
+    }
+
+    if (char === '"' || char === "'" || char === "`") {
+      stringDelimiter = char
+      continue
+    }
+
+    if (char === "{") {
+      depth++
+      continue
+    }
+
+    if (char === "}") {
+      depth--
+      if (depth === 0) {
+        return i
+      }
+    }
+  }
+
+  return -1
+}
+
+const fixObjectLiteralTemplateValues = (text: string): string =>
+  text.replace(/\\{2,}(?=`|\$\{)/g, "\\")
+
+const fixAssignedObjectTemplateValues = (
+  script: string,
+  variableName: string,
+): string => {
+  let out = script
+  let cursor = 0
+
+  while (cursor < out.length) {
+    const variableStart = findNextIdentifier(out, variableName, cursor)
+    if (variableStart === -1) {
+      break
+    }
+
+    let assignmentStart = skipWhitespace(
+      out,
+      variableStart + variableName.length,
+    )
+    if (out[assignmentStart] === ":") {
+      assignmentStart = findTypeAnnotationAssignment(out, assignmentStart + 1)
+      if (assignmentStart === -1) {
+        cursor = variableStart + variableName.length
+        continue
+      }
+    }
+
+    if (
+      out[assignmentStart] !== "=" ||
+      out[assignmentStart + 1] === "=" ||
+      out[assignmentStart + 1] === ">"
+    ) {
+      cursor = variableStart + variableName.length
+      continue
+    }
+
+    const objectStart = skipWhitespace(out, assignmentStart + 1)
+    if (out[objectStart] !== "{") {
+      cursor = objectStart + 1
+      continue
+    }
+
+    const objectEnd = findClosingBrace(out, objectStart)
+    if (objectEnd === -1) {
+      cursor = objectStart + 1
+      continue
+    }
+
+    const original = out.slice(objectStart, objectEnd + 1)
+    const escaped = fixObjectLiteralTemplateValues(original)
+    if (escaped !== original) {
+      out = `${out.slice(0, objectStart)}${escaped}${out.slice(objectEnd + 1)}`
+      cursor = objectEnd + (escaped.length - original.length) + 1
+      continue
+    }
+
+    cursor = objectEnd + 1
+  }
+
+  return out
+}
+
+const escapeRegExp = (text: string): string =>
+  text.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")
+
+const collectObjectEntryMapSources = (
+  script: string,
+  valueIdentifier: string,
+): ReadonlySet<string> => {
+  const out = new Set<string>()
+  const pattern = new RegExp(
+    `Object\\.entries\\(\\s*([A-Za-z_$][A-Za-z0-9_$]*)\\s*\\)\\s*\\.map\\(\\s*(?:async\\s*)?\\(\\s*\\[\\s*[A-Za-z_$][A-Za-z0-9_$]*\\s*,\\s*${escapeRegExp(valueIdentifier)}\\s*\\]\\s*\\)\\s*=>`,
+    "g",
+  )
+
+  for (const match of script.matchAll(pattern)) {
+    const sourceIdentifier = match[1]
+    if (sourceIdentifier !== undefined) {
+      out.add(sourceIdentifier)
+    }
+  }
+
+  return out
+}
+
 const findCallTemplateEnd = (
   text: string,
   templateStart: number,
@@ -641,10 +762,23 @@ const fixAssignedTemplatesForToolCalls = (script: string): string => {
     identifiers.add("patch")
   }
 
+  const objectTemplateIdentifiers = new Set<string>()
+  for (const identifier of identifiers) {
+    for (const sourceIdentifier of collectObjectEntryMapSources(
+      script,
+      identifier,
+    )) {
+      objectTemplateIdentifiers.add(sourceIdentifier)
+    }
+  }
+
   let out = script
   for (const identifier of identifiers) {
     out = fixAssignedTemplate(out, identifier)
   }
+  for (const identifier of objectTemplateIdentifiers) {
+    out = fixAssignedObjectTemplateValues(out, identifier)
+  }
   return out
 }
 

package/src/SemanticSearch.ts

@@ -42,10 +42,13 @@ export class SemanticSearch extends ServiceMap.Service<
 
 const normalizePath = (path: string) => path.replace(/\\/g, "/")
 
-const chunkConfig = {
+const resolveChunkConfig = (options: {
+  readonly chunkMaxCharacters?: number | undefined
+}) => ({
   chunkSize: 30,
   chunkOverlap: 0,
-} as const
+  chunkMaxCharacters: options.chunkMaxCharacters ?? 10_000,
+})
 
 export const makeEmbeddingResolver = (
   resolver: EmbeddingModel.Service["resolver"],
@@ -100,6 +103,7 @@ export const layer = (options: {
   readonly embeddingBatchSize?: number | undefined
   readonly embeddingRequestDelay?: Duration.Input | undefined
   readonly concurrency?: number | undefined
+  readonly chunkMaxCharacters?: number | undefined
 }): Layer.Layer<
   SemanticSearch,
   | SqlError.SqlError
@@ -121,6 +125,7 @@ export const layer = (options: {
       const root = pathService.resolve(options.directory)
       const resolver = makeEmbeddingResolver(embeddings.resolver, options)
       const concurrency = options.concurrency ?? 2000
+      const chunkConfig = resolveChunkConfig(options)
       const indexHandle = yield* FiberHandle.make()
       const console = yield* Console.Console
 

package/src/cli.ts

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+import * as Effect from "effect/Effect"
+import * as Prompt from "effect/unstable/cli/Prompt"
+import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient"
+import * as NodeServices from "@effect/platform-node/NodeServices"
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime"
+import * as NodeSocket from "@effect/platform-node/NodeSocket"
+import * as Codex from "./Codex.ts"
+import * as Copilot from "./Copilot.ts"
+import * as Agent from "./Agent.ts"
+import * as Stream from "effect/Stream"
+import * as OutputFormatter from "./OutputFormatter.ts"
+import * as Stdio from "effect/Stdio"
+import { pipe } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Path from "effect/Path"
+import * as Config from "effect/Config"
+import * as KeyValueStore from "effect/unstable/persistence/KeyValueStore"
+import * as SemanticSearch from "./SemanticSearch.ts"
+import * as Option from "effect/Option"
+import { OpenAiClient, OpenAiEmbeddingModel } from "@effect/ai-openai"
+
+const Kvs = Layer.unwrap(
+  Effect.gen(function* () {
+    const path = yield* Path.Path
+
+    const configHome = yield* Config.nonEmptyString("XDG_CONFIG_HOME").pipe(
+      Config.orElse(() =>
+        Config.nonEmptyString("HOME").pipe(
+          Config.map((home) => path.join(home, ".config")),
+        ),
+      ),
+    )
+    return KeyValueStore.layerFileSystem(path.join(configHome, "clanka"))
+  }),
+).pipe(Layer.provide(NodeServices.layer))
+
+const Search = Layer.unwrap(
+  Effect.gen(function* () {
+    const apiKey = yield* Config.redacted("OPENAI_API_KEY").pipe(Config.option)
+
+    if (Option.isNone(apiKey)) {
+      yield* Effect.logWarning("OPENAI_API_KEY is not set")
+      return Layer.empty
+    }
+
+    const path = yield* Path.Path
+
+    return SemanticSearch.layer({
+      directory: process.cwd(),
+      database: path.join(".clanka", "search.sqlite"),
+    }).pipe(
+      Layer.provide(
+        OpenAiEmbeddingModel.model("text-embedding-3-small", {
+          dimensions: 1536,
+        }),
+      ),
+      Layer.provide(
+        OpenAiClient.layer({
+          apiKey: apiKey.value,
+        }),
+      ),
+    )
+  }),
+).pipe(Layer.provide([NodeServices.layer, NodeHttpClient.layerUndici]))
+
+Effect.gen(function* () {
+  const stdio = yield* Stdio.Stdio
+
+  const provider = yield* Prompt.select({
+    message: "Select a provider",
+    choices: [
+      {
+        title: "openai",
+        value: "openai",
+        selected: true,
+      },
+      {
+        title: "copilot",
+        value: "copilot",
+      },
+    ],
+  })
+  const modelRaw = yield* Prompt.text({
+    message: "Enter a model",
+    default: "gpt-5.4/medium",
+    validate(value) {
+      const parts = value.split("/")
+      if (parts.length !== 2) {
+        return Effect.fail("Invalid model")
+      }
+      return Effect.succeed(value)
+    },
+  })
+  const semantic = yield* Prompt.confirm({
+    message: "Use semantic search? (uses OPENAI_API_KEY env var)",
+  })
+
+  const [model, reasoning] = modelRaw.split("/") as [string, string]
+  const Model =
+    provider === "openai"
+      ? Codex.modelWebSocket(model, {
+          reasoning: {
+            effort: reasoning as any,
+          },
+        }).pipe(
+          Layer.merge(
+            Agent.layerSubagentModel(
+              Codex.modelWebSocket("gpt-5.4-mini", {
+                reasoning: {
+                  effort: "high",
+                },
+              }),
+            ),
+          ),
+          Layer.provide(Codex.layerClient),
+        )
+      : Copilot.model(model, {
+          reasoning: {
+            effort: reasoning,
+          },
+        }).pipe(
+          Layer.merge(
+            Agent.layerSubagentModel(
+              Copilot.model(model, {
+                reasoning: {
+                  effort: "medium",
+                },
+              }),
+            ),
+          ),
+          Layer.provide(Copilot.layerClient),
+        )
+
+  return yield* Effect.gen(function* () {
+    const agent = yield* Agent.Agent
+
+    while (true) {
+      const prompt = yield* Prompt.text({
+        message: ">",
+      })
+
+      yield* pipe(
+        agent.send({ prompt }),
+        Stream.unwrap,
+        OutputFormatter.pretty({ outputTruncation: 30 }),
+        Stream.run(stdio.stdout()),
+      )
+
+      console.log("")
+    }
+  }).pipe(
+    Effect.provide([
+      Agent.layerLocal({
+        directory: process.cwd(),
+      }),
+      Model,
+      semantic ? Search : Layer.empty,
+    ]),
+  )
+}).pipe(
+  Effect.provide([
+    NodeServices.layer,
+    Kvs,
+    NodeHttpClient.layerUndici,
+    NodeSocket.layerWebSocketConstructorWS,
+  ]),
+  NodeRuntime.runMain,
+)

package/src/fixtures/patch12-broken.txt

@@ -0,0 +1,16 @@
+const files = {
+  '.changeset/green-seahorses-jump.md': `---\n"effect": minor\n---\n\nMigrate unstable \\`SqlError\\` to a reason-based shape (\\`new SqlError({ reason })\\`) with structured reason classes and retryable/classified reasons.`,
+  '.changeset/cool-islands-move.md': `---\n"@effect/sql-pg": minor\n---\n\nClassify PostgreSQL native/SQLSTATE failures into structured \\`SqlError\\` reasons and migrate driver construction to the reason-based \\`SqlError\\` shape.`,
+  '.changeset/curly-buckets-argue.md': `---\n"@effect/sql-mysql2": minor\n---\n\nClassify mysql2 native errno failures into structured \\`SqlError\\` reasons and migrate driver construction to the reason-based \\`SqlError\\` shape.`,
+  '.changeset/green-maps-think.md': `---\n"@effect/sql-mssql": minor\n---\n\nClassify MSSQL native error-number failures into structured \\`SqlError\\` reasons and migrate driver construction to the reason-based \\`SqlError\\` shape.`,
+  '.changeset/loud-gorillas-grab.md': `---\n"@effect/sql-sqlite-node": minor\n---\n\nClassify sqlite-node native SQLite failures into structured \\`SqlError\\` reasons and migrate driver construction to the reason-based \\`SqlError\\` shape.`,
+  '.changeset/late-brooms-decide.md': `---\n"@effect/sql-sqlite-bun": minor\n---\n\nClassify sqlite-bun native SQLite failures into structured \\`SqlError\\` reasons and migrate driver construction to the reason-based \\`SqlError\\` shape.`,
+  '.changeset/giant-dryers-sing.md': `---\n"@effect/sql-sqlite-wasm": minor\n---\n\nClassify sqlite-wasm native SQLite failures into structured \\`SqlError\\` reasons and migrate driver construction to the reason-based \\`SqlError\\` shape.`,
+  '.changeset/nice-walls-pull.md': `---\n"@effect/sql-sqlite-do": minor\n---\n\nClassify durable-object SQLite failures into structured \\`SqlError\\` reasons with Unknown fallback and migrate driver construction to reason-based \\`SqlError\\`.`,
+  '.changeset/flat-spoons-chew.md': `---\n"@effect/sql-sqlite-react-native": minor\n---\n\nClassify react-native SQLite failures into structured \\`SqlError\\` reasons and migrate driver construction to the reason-based \\`SqlError\\` shape.`,
+  '.changeset/metal-geese-fly.md': `---\n"@effect/sql-d1": minor\n---\n\nMigrate D1 driver \\`SqlError\\` construction to the reason-based shape and classify native failures into structured reasons with Unknown fallback when SQLite codes are unavailable.`,
+  '.changeset/clean-lions-hear.md': `---\n"@effect/sql-libsql": minor\n---\n\nClassify libSQL native failures into structured \\`SqlError\\` reasons (using SQLite code mapping where available) and migrate driver construction to reason-based \\`SqlError\\`.`,
+  '.changeset/fresh-bears-trace.md': `---\n"@effect/sql-clickhouse": minor\n---\n\nClassify ClickHouse native failures into structured \\`SqlError\\` reasons and migrate driver construction to the reason-based \\`SqlError\\` shape.`
+}
+await Promise.all(Object.entries(files).map(([path, content]) => writeFile({ path, content })))
+console.log('wrote', Object.keys(files).length, 'changesets')

package/src/fixtures/patch12-fixed.txt

@@ -0,0 +1,16 @@
+const files = {
+  '.changeset/green-seahorses-jump.md': `---\n"effect": minor\n---\n\nMigrate unstable \`SqlError\` to a reason-based shape (\`new SqlError({ reason })\`) with structured reason classes and retryable/classified reasons.`,
+  '.changeset/cool-islands-move.md': `---\n"@effect/sql-pg": minor\n---\n\nClassify PostgreSQL native/SQLSTATE failures into structured \`SqlError\` reasons and migrate driver construction to the reason-based \`SqlError\` shape.`,
+  '.changeset/curly-buckets-argue.md': `---\n"@effect/sql-mysql2": minor\n---\n\nClassify mysql2 native errno failures into structured \`SqlError\` reasons and migrate driver construction to the reason-based \`SqlError\` shape.`,
+  '.changeset/green-maps-think.md': `---\n"@effect/sql-mssql": minor\n---\n\nClassify MSSQL native error-number failures into structured \`SqlError\` reasons and migrate driver construction to the reason-based \`SqlError\` shape.`,
+  '.changeset/loud-gorillas-grab.md': `---\n"@effect/sql-sqlite-node": minor\n---\n\nClassify sqlite-node native SQLite failures into structured \`SqlError\` reasons and migrate driver construction to the reason-based \`SqlError\` shape.`,
+  '.changeset/late-brooms-decide.md': `---\n"@effect/sql-sqlite-bun": minor\n---\n\nClassify sqlite-bun native SQLite failures into structured \`SqlError\` reasons and migrate driver construction to the reason-based \`SqlError\` shape.`,
+  '.changeset/giant-dryers-sing.md': `---\n"@effect/sql-sqlite-wasm": minor\n---\n\nClassify sqlite-wasm native SQLite failures into structured \`SqlError\` reasons and migrate driver construction to the reason-based \`SqlError\` shape.`,
+  '.changeset/nice-walls-pull.md': `---\n"@effect/sql-sqlite-do": minor\n---\n\nClassify durable-object SQLite failures into structured \`SqlError\` reasons with Unknown fallback and migrate driver construction to reason-based \`SqlError\`.`,
+  '.changeset/flat-spoons-chew.md': `---\n"@effect/sql-sqlite-react-native": minor\n---\n\nClassify react-native SQLite failures into structured \`SqlError\` reasons and migrate driver construction to the reason-based \`SqlError\` shape.`,
+  '.changeset/metal-geese-fly.md': `---\n"@effect/sql-d1": minor\n---\n\nMigrate D1 driver \`SqlError\` construction to the reason-based shape and classify native failures into structured reasons with Unknown fallback when SQLite codes are unavailable.`,
+  '.changeset/clean-lions-hear.md': `---\n"@effect/sql-libsql": minor\n---\n\nClassify libSQL native failures into structured \`SqlError\` reasons (using SQLite code mapping where available) and migrate driver construction to reason-based \`SqlError\`.`,
+  '.changeset/fresh-bears-trace.md': `---\n"@effect/sql-clickhouse": minor\n---\n\nClassify ClickHouse native failures into structured \`SqlError\` reasons and migrate driver construction to the reason-based \`SqlError\` shape.`
+}
+await Promise.all(Object.entries(files).map(([path, content]) => writeFile({ path, content })))
+console.log('wrote', Object.keys(files).length, 'changesets')