@knpkv/jira-cli 1.1.2 → 1.2.1

package/src/VersionService.ts

@@ -26,7 +26,7 @@
  *
  * @module
  */
-import { JiraApiClient, toEffect } from "@knpkv/jira-api-client"
+import { JiraApiClient } from "@knpkv/jira-api-client"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
@@ -198,7 +198,9 @@ const EXPAND = "approvers,driver,operations,issuesstatus,contributors"
 
 /** Loosely-typed record helper for navigating untyped API JSON. */
 type Raw = Record<string, unknown>
-const asRaw = (v: unknown): Raw => (v && typeof v === "object" ? v as Raw : {})
+const isRaw = (value: unknown): value is Raw => typeof value === "object" && value !== null && !Array.isArray(value)
+const asRaw = (value: unknown): Raw => isRaw(value) ? value : {}
+const rawArray = (value: unknown): ReadonlyArray<Raw> => Array.isArray(value) ? value.filter(isRaw) : []
 
 /**
  * Render a Jira custom-field value as a flat string.
@@ -219,13 +221,13 @@ export const renderCustomFieldValue = (raw: unknown): string | null => {
     const parts = raw.map(renderCustomFieldValue).filter((v): v is string => !!v)
     return parts.length > 0 ? parts.join(", ") : null
   }
-  if (typeof raw === "object") {
-    const obj = raw as Raw
+  if (isRaw(raw)) {
+    const obj = raw
     const parent = stringOrNull(obj["value"])
     if (parent) {
       const child = obj["child"]
-      if (child && typeof child === "object") {
-        const childValue = stringOrNull((child as Raw)["value"])
+      if (isRaw(child)) {
+        const childValue = stringOrNull(child["value"])
         if (childValue) return `${parent} > ${childValue}`
       }
       return parent
@@ -241,8 +243,8 @@ export const renderCustomFieldValue = (raw: unknown): string | null => {
 const stringOrNull = (v: unknown): string | null => typeof v === "string" && v.length > 0 ? v : null
 
 export const personFromObject = (raw: unknown, fallbackId?: string): Person | null => {
-  if (raw && typeof raw === "object") {
-    const obj = raw as Raw
+  if (isRaw(raw)) {
+    const obj = raw
     const accountId = stringOrNull(obj["accountId"]) ?? fallbackId ?? null
     if (!accountId) return null
     return {
@@ -266,8 +268,8 @@ export const extractContributorIds = (raw: Raw): ReadonlyArray<string> => {
   const ids: Array<string> = []
   for (const c of field) {
     if (typeof c === "string" && c.length > 0) ids.push(c)
-    else if (c && typeof c === "object") {
-      const id = (c as Raw)["accountId"]
+    else if (isRaw(c)) {
+      const id = c["accountId"]
       if (typeof id === "string" && id.length > 0) ids.push(id)
     }
   }
@@ -297,31 +299,26 @@ const make = Effect.gen(function*() {
 
   const resolveFieldIds = (
     name: string
-  ): Effect.Effect<ReadonlyArray<string>, JiraApiError> => (Effect.gen(function*() {
-    const cached = fieldIdsByName.get(name)
-    if (cached !== undefined) return cached
-    const result = yield* toEffect(
-      client.v3.client.GET("/rest/api/3/field")
-    ).pipe(Effect.mapError((cause) => new JiraApiError({ message: `Failed to list Jira fields`, cause })))
-    const matches: Array<string> = []
-    if (Array.isArray(result)) {
-      for (const f of result) {
-        if (f && typeof f === "object") {
-          const obj = f as Raw
-          if (obj["name"] === name && typeof obj["id"] === "string") {
-            matches.push(obj["id"] as string)
-          }
+  ): Effect.Effect<ReadonlyArray<string>, JiraApiError> =>
+    Effect.gen(function*() {
+      const cached = fieldIdsByName.get(name)
+      if (cached !== undefined) return cached
+      const result = yield* client.getFields(undefined).pipe(
+        Effect.mapError((cause) => new JiraApiError({ message: `Failed to list Jira fields`, cause }))
+      )
+      const matches: Array<string> = []
+      for (const field of rawArray(result)) {
+        const id = field["id"]
+        if (field["name"] === name && typeof id === "string") {
+          matches.push(id)
         }
       }
-    }
-    fieldIdsByName.set(name, matches)
-    return matches
-  }) as Effect.Effect<ReadonlyArray<string>, JiraApiError>)
+      fieldIdsByName.set(name, matches)
+      return matches
+    })
 
   const fetchUser = (accountId: string): Effect.Effect<Person, never> =>
-    toEffect(
-      client.v3.client.GET("/rest/api/3/user", { params: { query: { accountId } } })
-    ).pipe(
+    client.getUser({ params: { accountId } }).pipe(
       Effect.map((u) => {
         const obj = asRaw(u)
         const person: Person = {
@@ -379,95 +376,92 @@ const make = Effect.gen(function*() {
     versionName: string,
     customFieldNames: ReadonlyArray<string>,
     projectKey?: string
-  ): Effect.Effect<ReadonlyArray<VersionTicket>, JiraApiError> => (Effect.gen(function*() {
-    const nameToIds = new Map<string, ReadonlyArray<string>>()
-    for (const name of customFieldNames) {
-      const ids = yield* resolveFieldIds(name)
-      nameToIds.set(name, ids)
-    }
-    const allFieldIds = new Set<string>()
-    for (const ids of nameToIds.values()) for (const id of ids) allFieldIds.add(id)
-    const requestedFields = ["assignee", "labels", "summary", ...allFieldIds]
-
-    const raws: Array<RawTicket> = []
-    const PAGE = 100
-    const MAX_PAGES = 100
-    let nextPageToken: string | undefined = undefined
-    for (let page = 0; page < MAX_PAGES; page++) {
-      const result = yield* toEffect(
-        client.v3.client.GET("/rest/api/3/search/jql", {
+  ): Effect.Effect<ReadonlyArray<VersionTicket>, JiraApiError> =>
+    Effect.gen(function*() {
+      const nameToIds = new Map<string, ReadonlyArray<string>>()
+      for (const name of customFieldNames) {
+        const ids = yield* resolveFieldIds(name)
+        nameToIds.set(name, ids)
+      }
+      const allFieldIds = new Set<string>()
+      for (const ids of nameToIds.values()) for (const id of ids) allFieldIds.add(id)
+      const requestedFields = ["assignee", "labels", "summary", ...allFieldIds]
+
+      const raws: Array<RawTicket> = []
+      const PAGE = 100
+      const MAX_PAGES = 100
+      let nextPageToken: string | undefined = undefined
+      for (let page = 0; page < MAX_PAGES; page++) {
+        const result = yield* client.searchIssuesUsingJql({
           params: {
-            query: {
-              jql: buildByVersionJql(versionName, projectKey),
-              fields: requestedFields,
-              maxResults: PAGE,
-              ...(nextPageToken ? { nextPageToken } : {})
-            }
+            jql: buildByVersionJql(versionName, projectKey),
+            fields: requestedFields,
+            maxResults: PAGE,
+            ...(nextPageToken ? { nextPageToken } : {})
           }
-        })
-      ).pipe(
-        Effect.mapError((cause) =>
-          new JiraApiError({ message: `Failed to fetch tickets for fixVersion "${versionName}"`, cause })
+        }).pipe(
+          Effect.mapError((cause) =>
+            new JiraApiError({ message: `Failed to fetch tickets for fixVersion "${versionName}"`, cause })
+          )
         )
-      )
 
-      const resObj = asRaw(result)
-      const issues = (Array.isArray(resObj["issues"]) ? resObj["issues"] : []) as Array<Raw>
-      for (const issue of issues) {
-        const key = typeof issue["key"] === "string" ? issue["key"] as string : ""
-        const fields = asRaw(issue["fields"])
-        const assignee = fields["assignee"]
-        let assigneeId: string | null = null
-        if (assignee && typeof assignee === "object") {
-          const accountId = (assignee as Raw)["accountId"]
-          if (typeof accountId === "string" && accountId.length > 0) assigneeId = accountId
-        }
-        const labelsRaw = fields["labels"]
-        const labels: Array<string> = []
-        if (Array.isArray(labelsRaw)) {
-          for (const l of labelsRaw) if (typeof l === "string" && l.length > 0) labels.push(l)
-        }
-        const customFields: Record<string, string | null> = {}
-        for (const name of customFieldNames) {
-          const ids = nameToIds.get(name) ?? []
-          let resolved: string | null = null
-          for (const id of ids) {
-            const v = renderCustomFieldValue(fields[id])
-            if (v !== null) {
-              resolved = v
-              break
+        const resObj = asRaw(result)
+        const issues = rawArray(resObj["issues"])
+        for (const issue of issues) {
+          const key = stringOrNull(issue["key"]) ?? ""
+          const fields = asRaw(issue["fields"])
+          const assignee = fields["assignee"]
+          let assigneeId: string | null = null
+          if (isRaw(assignee)) {
+            const accountId = assignee["accountId"]
+            if (typeof accountId === "string" && accountId.length > 0) assigneeId = accountId
+          }
+          const labelsRaw = fields["labels"]
+          const labels: Array<string> = []
+          if (Array.isArray(labelsRaw)) {
+            for (const l of labelsRaw) if (typeof l === "string" && l.length > 0) labels.push(l)
+          }
+          const customFields: Record<string, string | null> = {}
+          for (const name of customFieldNames) {
+            const ids = nameToIds.get(name) ?? []
+            let resolved: string | null = null
+            for (const id of ids) {
+              const v = renderCustomFieldValue(fields[id])
+              if (v !== null) {
+                resolved = v
+                break
+              }
             }
+            customFields[name] = resolved
           }
-          customFields[name] = resolved
+          raws.push({
+            key,
+            summary: stringOrNull(fields["summary"]),
+            assigneeId,
+            labels,
+            customFields
+          })
         }
-        raws.push({
-          key,
-          summary: stringOrNull(fields["summary"]),
-          assigneeId,
-          labels,
-          customFields
-        })
-      }
 
-      const isLast = resObj["isLast"]
-      const next = resObj["nextPageToken"]
-      if (isLast === true || typeof next !== "string" || next.length === 0) break
-      nextPageToken = next
-    }
-
-    const uniqueAssignees = Array.from(
-      new Set(raws.map((t) => t.assigneeId).filter((id): id is string => !!id))
-    )
-    yield* Effect.forEach(uniqueAssignees, (id) => resolveUser(id), { concurrency: 4 })
+        const isLast = resObj["isLast"]
+        const next = resObj["nextPageToken"]
+        if (isLast === true || typeof next !== "string" || next.length === 0) break
+        nextPageToken = next
+      }
 
-    return raws.map((t) => ({
-      key: t.key,
-      summary: t.summary,
-      assignee: t.assigneeId ? userCache.get(t.assigneeId) ?? null : null,
-      labels: t.labels,
-      customFields: t.customFields
-    }))
-  }) as Effect.Effect<ReadonlyArray<VersionTicket>, JiraApiError>)
+      const uniqueAssignees = Array.from(
+        new Set(raws.map((t) => t.assigneeId).filter((id): id is string => !!id))
+      )
+      yield* Effect.forEach(uniqueAssignees, (id) => resolveUser(id), { concurrency: 4 })
+
+      return raws.map((t) => ({
+        key: t.key,
+        summary: t.summary,
+        assignee: t.assigneeId ? userCache.get(t.assigneeId) ?? null : null,
+        labels: t.labels,
+        customFields: t.customFields
+      }))
+    })
 
   const mapVersion = (
     raw: Raw,
@@ -479,7 +473,7 @@ const make = Effect.gen(function*() {
       const name = String(raw["name"] ?? "")
       const driverId = stringOrNull(raw["driver"])
       const declared = extractContributorIds(raw)
-      const approversRaw = (Array.isArray(raw["approvers"]) ? raw["approvers"] : []) as Array<Raw>
+      const approversRaw = rawArray(raw["approvers"])
 
       const tickets = yield* ticketsForVersion(name, customFieldNames, projectKey)
 
@@ -548,75 +542,64 @@ const make = Effect.gen(function*() {
   const listProjectVersions = (
     projectKey: string,
     options?: ListVersionsOptions
-  ): Effect.Effect<ReadonlyArray<Version>, JiraApiError> => (Effect.gen(function*() {
-    const all: Array<Raw> = []
-    let startAt = 0
-    const cap = options?.maxResults
-    const customFieldNames = options?.customFieldNames ?? []
-    for (let page = 0; page < MAX_PAGES; page++) {
-      const result = yield* toEffect(
-        client.v3.client.GET("/rest/api/3/project/{projectIdOrKey}/version", {
+  ): Effect.Effect<ReadonlyArray<Version>, JiraApiError> =>
+    Effect.gen(function*() {
+      const all: Array<Raw> = []
+      let startAt = 0
+      const cap = options?.maxResults
+      const customFieldNames = options?.customFieldNames ?? []
+      for (let page = 0; page < MAX_PAGES; page++) {
+        const result = yield* client.getProjectVersionsPaginated(projectKey, {
           params: {
-            path: { projectIdOrKey: projectKey },
-            query: { startAt, maxResults: PAGE_SIZE, expand: EXPAND, orderBy: "-releaseDate" }
+            startAt,
+            maxResults: PAGE_SIZE,
+            expand: EXPAND,
+            orderBy: "-releaseDate"
           }
-        })
-      ).pipe(
-        Effect.mapError((cause) => new JiraApiError({ message: `Failed to list versions for ${projectKey}`, cause }))
-      )
+        }).pipe(
+          Effect.mapError((cause) => new JiraApiError({ message: `Failed to list versions for ${projectKey}`, cause }))
+        )
 
-      const resObj = asRaw(result)
-      const values = (Array.isArray(resObj["values"]) ? resObj["values"] : []) as Array<Raw>
-      for (const v of values) {
-        if (options?.released === true && v["released"] !== true) continue
-        if (options?.unreleased === true && v["released"] === true) continue
-        all.push(v)
+        const resObj = asRaw(result)
+        const values = rawArray(resObj["values"])
+        for (const v of values) {
+          if (options?.released === true && v["released"] !== true) continue
+          if (options?.unreleased === true && v["released"] === true) continue
+          all.push(v)
+          if (cap !== undefined && all.length >= cap) break
+        }
         if (cap !== undefined && all.length >= cap) break
+        const isLast = resObj["isLast"]
+        if (isLast === true || values.length < PAGE_SIZE) break
+        startAt += values.length
       }
-      if (cap !== undefined && all.length >= cap) break
-      const isLast = resObj["isLast"]
-      if (isLast === true || values.length < PAGE_SIZE) break
-      startAt += values.length
-    }
-    return yield* Effect.forEach(all, (r) => mapVersion(r, customFieldNames, projectKey), { concurrency: 4 })
-  }) as Effect.Effect<ReadonlyArray<Version>, JiraApiError>)
+      return yield* Effect.forEach(all, (r) => mapVersion(r, customFieldNames, projectKey), { concurrency: 4 })
+    })
 
   const getVersion = (id: string): Effect.Effect<Version, JiraApiError> =>
-    toEffect(
-      client.v3.client.GET("/rest/api/3/version/{id}", {
-        params: { path: { id }, query: { expand: EXPAND } }
-      })
-    ).pipe(
+    client.getVersion(id, { params: { expand: EXPAND } }).pipe(
       Effect.mapError((cause) => new JiraApiError({ message: `Failed to get version ${id}`, cause })),
       Effect.flatMap((raw) => mapVersion(asRaw(raw), []))
     )
 
   const updateVersion = (id: string, input: UpdateVersionInput): Effect.Effect<Version, JiraApiError> =>
-    toEffect(
-      client.v3.client.PUT("/rest/api/3/version/{id}", {
-        params: { path: { id } },
-        body: { ...(input.description !== undefined ? { description: input.description } : {}) }
-      })
-    ).pipe(
+    client.updateVersion(id, {
+      payload: { ...(input.description !== undefined ? { description: input.description } : {}) }
+    }).pipe(
       Effect.mapError((cause) => new JiraApiError({ message: `Failed to update version ${id}`, cause })),
       Effect.map((raw) => mapVersionScalar(asRaw(raw)))
     )
 
   const listRelatedWork = (id: string): Effect.Effect<ReadonlyArray<RelatedWork>, JiraApiError> =>
-    toEffect(
-      client.v3.client.GET("/rest/api/3/version/{id}/relatedwork", { params: { path: { id } } })
-    ).pipe(
+    client.getRelatedWork(id, undefined).pipe(
       Effect.mapError((cause) => new JiraApiError({ message: `Failed to list related work for version ${id}`, cause })),
       Effect.map((raw) => (Array.isArray(raw) ? raw : []).map(toRelatedWork))
     )
 
   const addRelatedWork = (id: string, input: AddRelatedWorkInput): Effect.Effect<RelatedWork, JiraApiError> =>
-    toEffect(
-      client.v3.client.POST("/rest/api/3/version/{id}/relatedwork", {
-        params: { path: { id } },
-        body: { title: input.title, category: input.category, url: input.url }
-      })
-    ).pipe(
+    client.createRelatedWork(id, {
+      payload: { title: input.title, category: input.category, url: input.url }
+    }).pipe(
       Effect.mapError((cause) => new JiraApiError({ message: `Failed to add related work to version ${id}`, cause })),
       Effect.map((raw) => {
         const w = toRelatedWork(raw)

package/src/bin.ts

@@ -66,7 +66,7 @@ const program = Effect.gen(function*() {
   )
 }).pipe(
   Effect.provide(NodeStdio.layer),
-  Effect.catchCause((cause) => handleError(cause))
+  Effect.catchCause((cause) => handleError(cause).pipe(Effect.andThen(Effect.failCause(cause))))
 )
 
-NodeRuntime.runMain(program)
+NodeRuntime.runMain(program, { disableErrorReporting: true })

package/src/commands/index.ts

@@ -7,5 +7,6 @@
 export { authCommand } from "./auth.js"
 export { handleError } from "./errorHandler.js"
 export { issueCommand } from "./issue.js"
+export { attachmentCommand } from "./issueAttachment.js"
 export { AppLayer, AuthOnlyLayer, getLayerType, MinimalLayer } from "./layers.js"
 export { versionCommand } from "./version.js"

package/src/commands/issue.ts

@@ -5,9 +5,10 @@
  */
 import { Command } from "effect/unstable/cli"
 import { getCommand } from "./get.js"
+import { attachmentCommand } from "./issueAttachment.js"
 import { searchCommand } from "./search.js"
 
 export const issueCommand = Command.make("issue").pipe(
-  Command.withDescription("Read-only Jira issue commands"),
-  Command.withSubcommands([getCommand, searchCommand])
+  Command.withDescription("Jira issue resource commands"),
+  Command.withSubcommands([attachmentCommand, getCommand, searchCommand])
 )

package/src/commands/issueAttachment.ts

@@ -0,0 +1,146 @@
+/**
+ * `jira issue attachment` resource commands.
+ *
+ * @internal
+ */
+import { renderAttachmentMarkdown } from "@knpkv/atlassian-common/attachments"
+import * as Console from "effect/Console"
+import * as Effect from "effect/Effect"
+import * as FileSystem from "effect/FileSystem"
+import * as Option from "effect/Option"
+import { Argument as Args, Command, Flag as Options } from "effect/unstable/cli"
+import { AttachmentService } from "../AttachmentService.js"
+import { insertJiraAttachmentReference } from "../internal/attachmentInsertion.js"
+import { JiraApiError, WriteError } from "../JiraCliError.js"
+
+const issueArg = Args.string("issue").pipe(
+  Args.withDescription("Issue key or id, for example PROJ-123")
+)
+
+const fileArg = Args.string("file").pipe(
+  Args.withDescription("Local file to upload")
+)
+
+const documentOption = Options.file("document").pipe(
+  Options.withDescription("Local Jira Markdown document containing the attachment placeholder"),
+  Options.optional
+)
+
+const noInsertOption = Options.boolean("no-insert").pipe(
+  Options.withDescription("Only upload and print the Attachment Reference")
+)
+
+const dryRunOption = Options.boolean("dry-run").pipe(
+  Options.withAlias("n"),
+  Options.withDescription("Validate local insertion input without uploading")
+)
+
+const jsonOption = Options.boolean("json").pipe(
+  Options.withDescription("Write exactly one JSON value to stdout")
+)
+
+const readDocument = (documentPath: string) =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    return yield* fs.readFileString(documentPath).pipe(
+      Effect.mapError((cause) =>
+        new WriteError({ path: documentPath, message: "Failed to read Jira Markdown document", cause })
+      )
+    )
+  })
+
+const writeDocument = (documentPath: string, content: string) =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    return yield* fs.writeFileString(documentPath, content).pipe(
+      Effect.mapError((cause) =>
+        new WriteError({ path: documentPath, message: "Failed to write Jira Markdown document", cause })
+      )
+    )
+  })
+
+const fileExists = (filePath: string) =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    return yield* fs.exists(filePath).pipe(
+      Effect.mapError((cause) => new WriteError({ path: filePath, message: "Failed to check attachment file", cause }))
+    )
+  })
+
+const uploadCommand = Command.make(
+  "upload",
+  {
+    issue: issueArg,
+    file: fileArg,
+    document: documentOption,
+    noInsert: noInsertOption,
+    dryRun: dryRunOption,
+    json: jsonOption
+  },
+  ({ document, dryRun, file, issue, json, noInsert }) =>
+    Effect.gen(function*() {
+      const documentPath = Option.isSome(document) ? document.value : null
+      const shouldInsert = !noInsert && documentPath !== null
+      const documentInput = shouldInsert
+        ? { path: documentPath, content: yield* readDocument(documentPath) }
+        : null
+
+      if (documentInput !== null) {
+        const matches = countPlaceholderMatches(documentInput.content, file)
+        if (matches !== 1) {
+          return yield* Effect.fail(
+            new JiraApiError({ message: `Expected exactly one attachment placeholder for ${file}, found ${matches}` })
+          )
+        }
+      }
+
+      if (dryRun) {
+        const exists = yield* fileExists(file)
+        if (!exists) {
+          return yield* Effect.fail(new JiraApiError({ message: `Attachment file does not exist: ${file}` }))
+        }
+        const result = { dryRun: true, issue, file, insert: shouldInsert }
+        yield* Console.log(json ? JSON.stringify(result) : `Dry run: ${file} can be uploaded to ${issue}`)
+        return
+      }
+
+      const service = yield* AttachmentService
+      const attachment = yield* service.uploadToIssue(issue, { filePath: file })
+      let inserted = false
+
+      if (documentInput !== null) {
+        const result = insertJiraAttachmentReference(documentInput.content, file, attachment)
+        if (result.replacements !== 1) {
+          return yield* Effect.fail(
+            new JiraApiError({
+              message:
+                `Uploaded attachment ${attachment.id}, but expected exactly one local placeholder for ${file}; found ${result.replacements}`
+            })
+          )
+        }
+        yield* writeDocument(documentInput.path, result.content)
+        inserted = true
+      }
+
+      if (json) {
+        yield* Console.log(JSON.stringify({ attachment, inserted }))
+      } else {
+        yield* Console.log(renderAttachmentMarkdown(attachment))
+        if (inserted) yield* Console.log(`Inserted into ${documentPath}`)
+      }
+    })
+).pipe(Command.withDescription("Remote write: upload a local file as a Jira issue attachment"))
+
+export const attachmentCommand = Command.make(
+  "attachment",
+  {},
+  () => Console.log("Usage: jira issue attachment upload <issue> <file>")
+).pipe(
+  Command.withDescription("Jira issue attachment commands"),
+  Command.withSubcommands([uploadCommand])
+)
+
+const countPlaceholderMatches = (content: string, placeholderPath: string): number => {
+  const escapedPath = placeholderPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+  return [...content.matchAll(new RegExp(`!?\\[[^\\]]*\\]\\(${escapedPath}\\)`, "g"))].length
+}

package/src/commands/layers.ts

@@ -16,6 +16,7 @@ import * as NodeServices from "@effect/platform-node/NodeServices"
 import { JiraApiClient, JiraApiConfig } from "@knpkv/jira-api-client"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import { AttachmentService, layer as AttachmentServiceLayer } from "../AttachmentService.js"
 import { IssueService, layer as IssueServiceLayer, SiteUrl } from "../IssueService.js"
 import { JiraAuth, layer as JiraAuthLayer } from "../JiraAuth.js"
 import { layer as MarkdownWriterLayer, MarkdownWriter } from "../MarkdownWriter.js"
@@ -31,6 +32,13 @@ const DummyIssueServiceLayer = Layer.succeed(
   })
 )
 
+const DummyAttachmentServiceLayer = Layer.succeed(
+  AttachmentService,
+  AttachmentService.of({
+    uploadToIssue: () => Effect.die(new Error("Not configured - run 'jira auth login' first"))
+  })
+)
+
 const DummyMarkdownWriterLayer = Layer.succeed(
   MarkdownWriter,
   MarkdownWriter.of({
@@ -82,15 +90,15 @@ const JiraConfigLive = Layer.unwrap(
     return Layer.succeed(JiraApiConfig, {
       baseUrl: "",
       auth: {
-        type: "oauth2" as const,
+        type: "oauth2",
         accessToken,
         cloudId
-      }
+      } satisfies { readonly type: "oauth2"; readonly accessToken: typeof accessToken; readonly cloudId: string }
     })
   })
 )
 
-// Build Jira API client layer with config (no HttpClient needed — uses openapi-fetch)
+// Build the generated Jira client with auth config and the shared Effect HttpClient.
 const JiraClientLive = JiraApiClient.layer.pipe(
   Layer.provide(JiraConfigLive)
 )
@@ -110,6 +118,7 @@ const SiteUrlLive = Layer.unwrap(
  * @category Layers
  */
 export const AppLayer = MarkdownWriterLayer.pipe(
+  Layer.provideMerge(AttachmentServiceLayer),
   Layer.provideMerge(IssueServiceLayer),
   Layer.provideMerge(VersionServiceLayer),
   Layer.provideMerge(SiteUrlLive),
@@ -125,6 +134,7 @@ export const AppLayer = MarkdownWriterLayer.pipe(
  * @category Layers
  */
 export const AuthOnlyLayer = DummyIssueServiceLayer.pipe(
+  Layer.provideMerge(DummyAttachmentServiceLayer),
   Layer.provideMerge(DummyMarkdownWriterLayer),
   Layer.provideMerge(DummyVersionServiceLayer),
   Layer.provideMerge(AuthLive),
@@ -138,6 +148,7 @@ export const AuthOnlyLayer = DummyIssueServiceLayer.pipe(
  * @category Layers
  */
 export const MinimalLayer = DummyIssueServiceLayer.pipe(
+  Layer.provideMerge(DummyAttachmentServiceLayer),
   Layer.provideMerge(DummyMarkdownWriterLayer),
   Layer.provideMerge(DummyVersionServiceLayer),
   Layer.provideMerge(DummyJiraAuthLayer),
@@ -157,6 +168,12 @@ export const getLayerType = (args: ReadonlyArray<string>): "full" | "auth" | "mi
   if (cmd === "auth") {
     return "auth"
   }
+  if (
+    cmd === "issue" && args[1] === "attachment" && args[2] === "upload" &&
+    (args.includes("--dry-run") || args.includes("-n"))
+  ) {
+    return "minimal"
+  }
   if (!cmd || cmd === "skills" || cmd === "--help" || cmd === "-h" || cmd === "--version") {
     return "minimal"
   }