infra-kit 0.1.105 → 0.1.108

package/src/integrations/gh/gh-release-prs/__tests__/gh-release-prs.test.ts

@@ -1,6 +1,8 @@
+import { execFileSync } from 'node:child_process'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { quote } from 'zx'
 
-import { getReleasePRs, getReleasePRsWithInfo } from '../gh-release-prs'
+import { createReleaseBranch, getReleasePRs, getReleasePRsWithInfo } from '../gh-release-prs'
 
 interface FakePR {
   number: number
@@ -12,17 +14,32 @@ interface FakePR {
 }
 
 const responses = vi.hoisted(() => {
-  return { release: [] as FakePR[], hotfix: [] as FakePR[] }
+  return {
+    release: [] as FakePR[],
+    hotfix: [] as FakePR[],
+    calls: [] as { strings: string[]; values: unknown[] }[],
+  }
 })
 
 // Mock zx's tagged-template `$`: the gh pr list call for `--base dev` returns
-// the "release" set, `--base main` returns the "hotfix" set. The command is
-// reconstructed from the template strings so we can branch on the base flag.
-vi.mock('zx', () => {
+// the "release" set, `--base main` returns the "hotfix" set, and `gh pr create`
+// returns a fake PR URL. Every invocation is captured (template strings +
+// interpolated values) so tests can reconstruct the exact command zx would run.
+// Spreading `...actual` keeps zx's real `quote` available for that reconstruction.
+vi.mock('zx', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('zx')>()
+
   return {
-    $: vi.fn((strings: TemplateStringsArray) => {
+    ...actual,
+    $: vi.fn((strings: TemplateStringsArray, ...values: unknown[]) => {
       const command = strings.join('')
 
+      responses.calls.push({ strings: [...strings], values })
+
+      if (command.includes('gh pr create')) {
+        return Promise.resolve({ stdout: 'https://github.com/acme/repo/pull/123' })
+      }
+
       if (command.includes('--base main')) {
         return Promise.resolve({ stdout: JSON.stringify(responses.hotfix) })
       }
@@ -113,3 +130,69 @@ describe('getReleasePRsWithInfo (discovery + sort)', () => {
     ])
   })
 })
+
+describe('createReleaseBranch (gh pr create title quoting)', () => {
+  beforeEach(() => {
+    responses.calls = []
+  })
+
+  // Rebuild the exact command zx would have run: interleave each template
+  // string with the zx-quoted form of its interpolated value. This reflects
+  // what the shell actually receives, including zx's ANSI-C `$'...'` escaping
+  // for values containing spaces.
+  const reconstruct = (call: { strings: string[]; values: unknown[] }): string => {
+    return call.strings
+      .map((part, i) => {
+        return i < call.values.length ? part + quote(String(call.values[i])) : part
+      })
+      .join('')
+  }
+
+  const findCreateCommand = (): string => {
+    const call = responses.calls.find((c) => {
+      return c.strings.join('').includes('gh pr create')
+    })
+
+    if (!call) throw new Error('gh pr create was not invoked')
+
+    return reconstruct(call)
+  }
+
+  // Run the reconstructed command through a real shell with `gh pr create`
+  // replaced by a function that prints back the value the shell parsed for
+  // `--title`. This is the behavioral proof of what gh would receive.
+  const shellTitleArg = (command: string): string => {
+    const probe = command.replace(
+      'gh pr create',
+      'f(){ while [ "$#" -gt 0 ]; do if [ "$1" = "--title" ]; then printf %s "$2"; return 0; fi; shift; done; }; f',
+    )
+
+    // Absolute path (not PATH-resolved) keeps the lint's command-injection guard happy.
+    return execFileSync('/bin/sh', ['-c', probe]).toString()
+  }
+
+  it("delivers a spaced title to gh as the literal string, with no $'...' corruption", async () => {
+    const id = { kind: 'version', semver: { major: 1, minor: 89, patch: 1 }, raw: '1.89.1' } as const
+
+    await createReleaseBranch({ id, jiraVersionUrl: 'https://jira.example/v1.89.1', type: 'hotfix' })
+
+    const command = findCreateCommand()
+
+    // Behavioral: the shell parses --title to exactly the intended title.
+    expect(shellTitleArg(command)).toBe('Hotfix v1.89.1')
+    // The pre-fix bug wrapped zx's `$'...'` token in literal double quotes, so
+    // the shell passed the literal `$'Hotfix v1.89.1'` to gh. That marker must be absent.
+    expect(command).not.toContain('"$\'')
+  })
+
+  it('delivers a named release title to gh as the literal string', async () => {
+    const id = { kind: 'name', name: 'checkout-redesign', raw: 'checkout-redesign' } as const
+
+    await createReleaseBranch({ id, jiraVersionUrl: 'https://jira.example/checkout-redesign', type: 'regular' })
+
+    const command = findCreateCommand()
+
+    expect(shellTitleArg(command)).toBe('Release checkout-redesign')
+    expect(command).not.toContain('"$\'')
+  })
+})

package/src/integrations/gh/gh-release-prs/gh-release-prs.ts

@@ -178,7 +178,7 @@ export const createReleaseBranch = async (
     await $`git push origin ${branchName}`
 
     // Create PR and capture URL
-    const prResult = await $`gh pr create --title "${prTitle}" --body ${body} --base ${baseBranch} --head ${branchName}`
+    const prResult = await $`gh pr create --title ${prTitle} --body ${body} --base ${baseBranch} --head ${branchName}`
 
     const prLink = prResult.stdout.trim()
 

package/src/lib/managed-block/__tests__/managed-block.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from 'vitest'
+
+import { extractVersion, hasManagedBlock, removeManagedBlock, upsertManagedBlock } from '../managed-block'
+
+const START = '<!-- ik:begin -->'
+const END = '<!-- ik:end -->'
+
+describe('hasManagedBlock', () => {
+  it('detects a well-formed block', () => {
+    expect(hasManagedBlock(`x ${START} y ${END} z`, START, END)).toBe(true)
+  })
+
+  it('returns false when a marker is missing', () => {
+    expect(hasManagedBlock(`only ${START} here`, START, END)).toBe(false)
+  })
+
+  it('treats reversed markers (end before start) as absent', () => {
+    expect(hasManagedBlock(`${END} middle ${START}`, START, END)).toBe(false)
+  })
+})
+
+describe('removeManagedBlock', () => {
+  it('removes the block and preserves surrounding text', () => {
+    const content = `top\n${START}\nmid\n${END}\nbot`
+
+    expect(removeManagedBlock(content, START, END)).toBe('top\nbot')
+  })
+
+  it('returns null when no block is present', () => {
+    expect(removeManagedBlock('nothing here', START, END)).toBeNull()
+  })
+
+  it('returns null for reversed markers (guard)', () => {
+    expect(removeManagedBlock(`${END}\nx\n${START}`, START, END)).toBeNull()
+  })
+})
+
+describe('extractVersion', () => {
+  const PREFIX = '<!-- ik:version '
+
+  it('reads the version token after the prefix', () => {
+    expect(extractVersion('<!-- ik:version 0.1.105 -->', PREFIX)).toBe('0.1.105')
+  })
+
+  it('returns null when the prefix is absent', () => {
+    expect(extractVersion('no version here', PREFIX)).toBeNull()
+  })
+})
+
+describe('upsertManagedBlock', () => {
+  it('inserts into an empty file (replace-in-place default)', () => {
+    const result = upsertManagedBlock({ content: '', body: 'hello', startMarker: START, endMarker: END })
+
+    expect(result).toBe(`${START}\nhello\n${END}\n`)
+  })
+
+  it('inserts into an empty file (append-end)', () => {
+    const result = upsertManagedBlock({
+      content: '',
+      body: 'hello',
+      startMarker: START,
+      endMarker: END,
+      placement: 'append-end',
+    })
+
+    expect(result).toBe(`${START}\nhello\n${END}\n`)
+  })
+
+  it('replaces an existing block in place, keeping surrounding content verbatim', () => {
+    const content = `# top heading\n\n${START}\nold body\n${END}\n\n# bottom heading\n`
+    const result = upsertManagedBlock({ content, body: 'new body', startMarker: START, endMarker: END })
+
+    expect(result).toBe(`# top heading\n\n${START}\nnew body\n${END}\n\n# bottom heading\n`)
+  })
+
+  it('append-end relocates an existing mid-file block to end-of-file', () => {
+    const content = `intro\n\n${START}\nold\n${END}\n\nuser tail`
+    const result = upsertManagedBlock({
+      content,
+      body: 'fresh',
+      startMarker: START,
+      endMarker: END,
+      placement: 'append-end',
+    })
+
+    expect(result).toBe(`intro\nuser tail\n${START}\nfresh\n${END}\n`)
+  })
+
+  it('append-end lands the block at end-of-file when absent', () => {
+    const content = 'existing user content'
+    const result = upsertManagedBlock({
+      content,
+      body: 'b',
+      startMarker: START,
+      endMarker: END,
+      placement: 'append-end',
+    })
+
+    expect(result.endsWith(`${START}\nb\n${END}\n`)).toBe(true)
+    expect(result.startsWith('existing user content')).toBe(true)
+  })
+
+  it('is idempotent — re-running does not nest or duplicate blocks', () => {
+    const once = upsertManagedBlock({ content: 'pre\n', body: 'b', startMarker: START, endMarker: END })
+    const twice = upsertManagedBlock({ content: once, body: 'b', startMarker: START, endMarker: END })
+
+    expect(twice).toBe(once)
+    expect(twice.match(new RegExp(START, 'g'))?.length).toBe(1)
+  })
+
+  it('preserves content above and below across an update', () => {
+    const first = upsertManagedBlock({ content: 'ABOVE\n', body: 'v1', startMarker: START, endMarker: END })
+    const withTail = `${first}BELOW\n`
+    const updated = upsertManagedBlock({ content: withTail, body: 'v2', startMarker: START, endMarker: END })
+
+    expect(updated).toContain('ABOVE')
+    expect(updated).toContain('BELOW')
+    expect(updated).toContain('v2')
+    expect(updated).not.toContain('v1')
+  })
+})

package/src/lib/managed-block/index.ts

@@ -0,0 +1,8 @@
+export {
+  buildManagedBlock,
+  extractVersion,
+  hasManagedBlock,
+  removeManagedBlock,
+  upsertManagedBlock,
+} from './managed-block'
+export type { BlockPlacement, UpsertManagedBlockArgs } from './managed-block'

package/src/lib/managed-block/managed-block.ts

@@ -0,0 +1,145 @@
+/**
+ * Generic "managed block" helpers — a marker-delimited region a tool owns and
+ * rewrites idempotently while never touching content outside the markers.
+ *
+ * This is the same mechanism `infra-kit init` already uses for the `~/.zshrc`
+ * shell block (`# -- infra-kit:begin -- … # -- infra-kit:end --`), lifted here so
+ * it can be reused for the repo agent-instruction files (`AGENTS.md`,
+ * `CLAUDE.md` import region, `.cursor/rules`). It mirrors the design of OMC's
+ * `<!-- OMC:START --> … <!-- OMC:END -->` CLAUDE.md installer.
+ */
+
+/**
+ * Where a freshly upserted block lands relative to existing content.
+ *
+ * - `replace-in-place`: if the block already exists, rewrite it where it sits
+ *   (surrounding text untouched, verbatim); if absent, append it at end-of-file.
+ * - `append-end`: strip any existing block from wherever it is, then append the
+ *   fresh block at end-of-file (i.e. always relocate to the end). This preserves
+ *   the historical `~/.zshrc` behavior of `removeExistingBlock` + append.
+ */
+export type BlockPlacement = 'replace-in-place' | 'append-end'
+
+export interface UpsertManagedBlockArgs {
+  /** Existing file content (`''` for a new file). */
+  content: string
+  /** Inner body to place between the markers (WITHOUT the markers). */
+  body: string
+  startMarker: string
+  endMarker: string
+  /** Defaults to `replace-in-place`. */
+  placement?: BlockPlacement
+}
+
+/**
+ * Whether `content` contains a well-formed `start … end` block. A reversed pair
+ * (end before start) is treated as absent — the same guard `doctor.ts` applies
+ * to the zshrc block, ported here so corrupted markers never match.
+ *
+ * @example
+ * hasManagedBlock('a<!--s-->x<!--e-->b', '<!--s-->', '<!--e-->') // => true
+ * hasManagedBlock('<!--e--><!--s-->', '<!--s-->', '<!--e-->')    // => false (reversed)
+ */
+export const hasManagedBlock = (content: string, startMarker: string, endMarker: string): boolean => {
+  const startIdx = content.indexOf(startMarker)
+  const endIdx = content.indexOf(endMarker)
+
+  return startIdx !== -1 && endIdx !== -1 && endIdx >= startIdx
+}
+
+/**
+ * Remove the first complete `start … end` block, preserving surrounding text.
+ * Returns `null` when no well-formed block is present (no markers, or reversed),
+ * so callers can fall through to legacy-format handling — this matches the
+ * `string | null` contract of `init.ts`'s original `removeBetween`, with the
+ * added reversed-marker guard.
+ *
+ * @example
+ * removeManagedBlock('top\n<!--s-->mid<!--e-->\nbot', '<!--s-->', '<!--e-->')
+ * // => 'top\nbot'
+ */
+export const removeManagedBlock = (content: string, startMarker: string, endMarker: string): string | null => {
+  const startIdx = content.indexOf(startMarker)
+  const endIdx = content.indexOf(endMarker)
+
+  if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) return null
+
+  // eslint-disable-next-line sonarjs/slow-regex
+  const before = content.slice(0, startIdx).replace(/\n+$/, '')
+  const after = content.slice(endIdx + endMarker.length).replace(/^\n+/, '')
+
+  return before + (after ? `\n${after}` : '')
+}
+
+/**
+ * Read the version token that follows `versionPrefix` (e.g.
+ * `'<!-- infra-kit:version '`). Returns the token up to the next whitespace or
+ * `>`, or `null` if the prefix is absent. Mirrors OMC's `OMC:VERSION:` line.
+ *
+ * @example
+ * extractVersion('<!-- infra-kit:version 0.1.105 -->', '<!-- infra-kit:version ')
+ * // => '0.1.105'
+ */
+export const extractVersion = (content: string, versionPrefix: string): string | null => {
+  const idx = content.indexOf(versionPrefix)
+
+  if (idx === -1) return null
+
+  const rest = content.slice(idx + versionPrefix.length)
+  const match = rest.match(/^([^\s>]+)/)
+
+  return match ? match[1]! : null
+}
+
+/**
+ * Compose a full block string: `start\n{body}\nend`. Kept identical in shape to
+ * the historical `buildShellBlock()` output so doctor's exact-match comparison
+ * stays valid.
+ */
+export const buildManagedBlock = (startMarker: string, body: string, endMarker: string): string => {
+  return `${startMarker}\n${body}\n${endMarker}`
+}
+
+/**
+ * Insert or update a managed block in `content`, preserving everything outside
+ * the markers. Idempotent: re-running with the same body yields the same block
+ * and never nests duplicates.
+ *
+ * @example
+ * // fresh file
+ * upsertManagedBlock({ content: '', body: 'hi', startMarker: '<!--s-->', endMarker: '<!--e-->' })
+ * // => '<!--s-->\nhi\n<!--e-->\n'
+ *
+ * @example
+ * // existing block replaced in place, surrounding text kept
+ * upsertManagedBlock({
+ *   content: 'top\n<!--s-->\nold\n<!--e-->\nbot',
+ *   body: 'new', startMarker: '<!--s-->', endMarker: '<!--e-->',
+ * })
+ * // => 'top\n<!--s-->\nnew\n<!--e-->\nbot'
+ */
+export const upsertManagedBlock = ({
+  content,
+  body,
+  startMarker,
+  endMarker,
+  placement = 'replace-in-place',
+}: UpsertManagedBlockArgs): string => {
+  const block = buildManagedBlock(startMarker, body, endMarker)
+  const present = hasManagedBlock(content, startMarker, endMarker)
+
+  if (placement === 'replace-in-place' && present) {
+    const startIdx = content.indexOf(startMarker)
+    const endIdx = content.indexOf(endMarker) + endMarker.length
+
+    return content.slice(0, startIdx) + block + content.slice(endIdx)
+  }
+
+  // append-end, or replace-in-place with no existing block: drop any stale block
+  // then append the fresh one at end-of-file.
+  const stripped = present ? (removeManagedBlock(content, startMarker, endMarker) ?? content) : content
+  // eslint-disable-next-line sonarjs/slow-regex
+  const base = stripped.replace(/\n+$/, '')
+
+  return base.length > 0 ? `${base}\n${block}\n` : `${block}\n`
+}