infra-kit 0.1.102 → 0.1.107

package/src/commands/init/init.ts

@@ -3,6 +3,10 @@ import os from 'node:os'
 import path from 'node:path'
 
 import { logger } from 'src/lib/logger'
+import { removeManagedBlock, upsertManagedBlock } from 'src/lib/managed-block'
+
+import { writeAgentFiles } from './agent-files'
+import { migrateLegacyConfig } from './migrate-config'
 
 export const MARKER_START = '# -- infra-kit:begin --'
 export const MARKER_END = '# -- infra-kit:end --'
@@ -10,76 +14,94 @@ export const MARKER_END = '# -- infra-kit:end --'
 const LEGACY_PAIRED: [start: string, end: string][] = [['# region infra-kit', '# endregion infra-kit']]
 const LEGACY_SINGLE = '# infra-kit shell functions'
 
-const USER_GLOBAL_CONFIG_STUB = `# infra-kit user-global config — ~/.infra-kit/config.yml
-#
-# Merge chain (later layers override earlier ones at top-level keys):
-#   1. <repo>/infra-kit.yml                            — committed project config (required)
-#   2. ~/.infra-kit/config.yml                         — this file (user-global)
-#   3. ~/.infra-kit/projects/<repo-name>/infra-kit.yml — user-scope per-project override
-#
-# Merge is shallow: setting a top-level key here replaces that whole section
-# from layer 1. Arrays do not concatenate. Top-level keys recognized:
-# environments, envManagement, ide, taskManager, worktrees.
-#
-# Uncomment the blocks you want to apply globally across every project on this
-# machine. Per-project tweaks belong in layer 3 — run \`infra-kit config edit\`.
-
-# Per-developer IDE config
-# ide:
-#   provider: cursor
-#   config:
-#     mode: workspace
-#     workspaceConfigPath: /path/to/your.code-workspace
-
-# Worktree prompt defaults — silences the follow-up prompts in \`worktrees-add\`
-# worktrees:
-#   openInGithubDesktop: false
-#   openInCmux: true
+// JSON can't carry comments, so the real config is an empty-but-valid object…
+const USER_GLOBAL_CONFIG_STUB = '{}\n'
+
+// …and the annotated guidance lives next to it in a non-loaded .example.jsonc
+// (the loader only reads the three exact `infra-kit.json` / `config.json` files).
+const USER_GLOBAL_CONFIG_EXAMPLE = `// infra-kit user-global config — ~/.infra-kit/config.json
+//
+// Merge chain (later layers override earlier ones at top-level keys):
+//   1. <repo>/infra-kit.json                            — committed project config (required)
+//   2. ~/.infra-kit/config.json                         — user-global (the sibling of this file)
+//   3. ~/.infra-kit/projects/<repo-name>/infra-kit.json — user-scope per-project override
+//
+// Merge is shallow: setting a top-level key replaces that whole section from
+// layer 1. Arrays do not concatenate. Top-level keys recognized:
+// environments, envManagement, ide, taskManager, worktrees.
+//
+// This .example.jsonc is reference only — it is NOT loaded. Put real global
+// overrides in the sibling config.json (strict JSON: no comments, double-quoted
+// keys). Per-project tweaks belong in layer 3 — run \`infra-kit config edit\`.
+{
+  // "ide": {
+  //   "provider": "cursor",
+  //   "config": { "mode": "workspace", "workspaceConfigPath": "/path/to/your.code-workspace" }
+  // },
+  // "worktrees": { "openInGithubDesktop": false, "openInCmux": true }
+}
 `
 
 /**
- * Append infra-kit shell functions to .zshrc and seed the user-global
- * config stub at ~/.infra-kit/config.yml on first run. Idempotent: a
- * subsequent run replaces the existing zshrc block in place and leaves
+ * Append infra-kit shell functions to .zshrc, migrate any legacy
+ * `infra-kit.yml` config layers to JSON, and seed the user-global config at
+ * ~/.infra-kit/config.json on first run. Idempotent: a subsequent run replaces
+ * the existing zshrc block in place, has nothing left to migrate, and leaves
  * the user-global config untouched.
  *
  * @example
  * // CLI: `infra-kit init`  (or via the `pnpm dx-init` alias)
  * // INFO: Added infra-kit shell functions to /Users/me/.zshrc
- * // INFO: Wrote user-global config stub to /Users/me/.infra-kit/config.yml
+ * // INFO: Wrote user-global config to /Users/me/.infra-kit/config.json (see …/config.example.jsonc …)
  * // INFO: Run `source ~/.zshrc` or open a new terminal to activate.
  */
 export const init = async (): Promise<void> => {
   const zshrcPath = path.join(os.homedir(), '.zshrc')
-  const shellBlock = buildShellBlock()
 
-  if (fs.existsSync(zshrcPath)) {
-    const content = fs.readFileSync(zshrcPath, 'utf-8')
-    const cleaned = removeExistingBlock(content)
+  // Strip any prior block (current or legacy markers) anywhere in the file, then
+  // append a fresh block at end-of-file via the shared managed-block utility —
+  // the historical `removeExistingBlock` + append behavior, now centralized.
+  const existing = fs.existsSync(zshrcPath) ? removeExistingBlock(fs.readFileSync(zshrcPath, 'utf-8')) : ''
 
-    fs.writeFileSync(zshrcPath, cleaned)
-  }
+  const updated = upsertManagedBlock({
+    content: existing,
+    body: buildShellBody(),
+    startMarker: MARKER_START,
+    endMarker: MARKER_END,
+    placement: 'append-end',
+  })
+
+  fs.writeFileSync(zshrcPath, updated)
 
-  fs.appendFileSync(zshrcPath, `\n${shellBlock}\n`)
   logger.info(`Added infra-kit shell functions to ${zshrcPath}`)
 
+  // Convert any legacy infra-kit.yml config layers to JSON before seeding, so a
+  // migrated config.json is not re-seeded as an empty stub.
+  await migrateLegacyConfig()
+
   seedUserGlobalConfig()
 
+  // Best-effort, non-fatal, repo-gated: keep the agent-instruction files in sync
+  // with the CLI surface. A no-op outside an infra-kit repo.
+  await writeAgentFiles()
+
   logger.info('Run `source ~/.zshrc` or open a new terminal to activate.')
 }
 
 /**
- * Create `~/.infra-kit/config.yml` with the documented stub when absent.
- * Skips silently if the file already exists so user edits are preserved.
+ * Create `~/.infra-kit/config.json` (empty `{}`) plus an annotated
+ * `~/.infra-kit/config.example.jsonc` reference when absent. Skips silently if
+ * the config already exists so user edits are preserved.
  *
  * @example
  * seedUserGlobalConfig()
- * // first call:  writes ~/.infra-kit/config.yml from USER_GLOBAL_CONFIG_STUB
- * // later calls: leaves the file alone, logs that it is already present
+ * // first call:  writes ~/.infra-kit/config.json ({}) + config.example.jsonc
+ * // later calls: leaves the config alone, logs that it is already present
  */
 const seedUserGlobalConfig = (): void => {
   const userConfigDir = path.join(os.homedir(), '.infra-kit')
-  const userConfigPath = path.join(userConfigDir, 'config.yml')
+  const userConfigPath = path.join(userConfigDir, 'config.json')
+  const userConfigExamplePath = path.join(userConfigDir, 'config.example.jsonc')
 
   if (fs.existsSync(userConfigPath)) {
     logger.info(`User-global config already present at ${userConfigPath}`)
@@ -89,8 +111,11 @@ const seedUserGlobalConfig = (): void => {
 
   fs.mkdirSync(userConfigDir, { recursive: true })
   fs.writeFileSync(userConfigPath, USER_GLOBAL_CONFIG_STUB, 'utf-8')
+  fs.writeFileSync(userConfigExamplePath, USER_GLOBAL_CONFIG_EXAMPLE, 'utf-8')
 
-  logger.info(`Wrote user-global config stub to ${userConfigPath}`)
+  logger.info(
+    `Wrote user-global config to ${userConfigPath} (see ${userConfigExamplePath} for the annotated reference)`,
+  )
 }
 
 const isBlockLine = (line: string): boolean => {
@@ -112,28 +137,15 @@ const isBlockLine = (line: string): boolean => {
   )
 }
 
-const removeBetween = (content: string, start: string, end: string): string | null => {
-  const startIdx = content.indexOf(start)
-  const endIdx = content.indexOf(end)
-
-  if (startIdx === -1 || endIdx === -1) return null
-
-  // eslint-disable-next-line sonarjs/slow-regex
-  const before = content.slice(0, startIdx).replace(/\n+$/, '')
-  const after = content.slice(endIdx + end.length).replace(/^\n+/, '')
-
-  return before + (after ? `\n${after}` : '')
-}
-
 const removeExistingBlock = (content: string): string => {
   // 1. Current markers
-  const result = removeBetween(content, MARKER_START, MARKER_END)
+  const result = removeManagedBlock(content, MARKER_START, MARKER_END)
 
   if (result !== null) return result
 
   // 2. Legacy paired markers (# region / # endregion)
   for (const [start, end] of LEGACY_PAIRED) {
-    const legacyResult = removeBetween(content, start, end)
+    const legacyResult = removeManagedBlock(content, start, end)
 
     if (legacyResult !== null) return legacyResult
   }
@@ -158,11 +170,14 @@ const removeExistingBlock = (content: string): string => {
   return before + (remaining ? `\n${remaining}` : '')
 }
 
-export const buildShellBlock = (): string => {
+/**
+ * The inner shell-function lines (no markers). Composed into the full marked
+ * block by {@link buildShellBlock} and fed to `upsertManagedBlock` by `init()`.
+ */
+export const buildShellBody = (): string => {
   const runCmd = 'pnpm exec infra-kit'
 
   return [
-    MARKER_START,
     'zmodload zsh/stat 2>/dev/null',
     'zmodload zsh/datetime 2>/dev/null',
     // eslint-disable-next-line no-template-curly-in-string
@@ -210,6 +225,13 @@ export const buildShellBlock = (): string => {
     'if (( _INFRA_KIT_SHELL_STARTED > 0 )); then',
     '  add-zsh-hook precmd _infra_kit_autoload',
     'fi',
-    MARKER_END,
   ].join('\n')
 }
+
+/**
+ * The full marker-delimited shell block (`MARKER_START … MARKER_END`). Kept as
+ * a single composed string so `doctor`'s exact-match freshness check stays valid.
+ */
+export const buildShellBlock = (): string => {
+  return `${MARKER_START}\n${buildShellBody()}\n${MARKER_END}`
+}

package/src/commands/init/migrate-config.ts

@@ -0,0 +1,146 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import yaml from 'yaml'
+import { z } from 'zod'
+
+import {
+  getInfraKitConfigPaths,
+  infraKitConfigSchema,
+  infraKitOverrideConfigSchema,
+  resetInfraKitConfigCache,
+} from 'src/lib/infra-kit-config'
+import { logger } from 'src/lib/logger'
+
+interface MigrateLayer {
+  label: string
+  /** Legacy YAML source path. */
+  yml: string
+  /** Target JSON path. */
+  json: string
+  /** Validates the parsed object before any write (main vs override schema). */
+  schema: z.ZodType
+}
+
+/**
+ * Replace the user's home prefix with `~` so logged paths stay short.
+ *
+ * @example
+ * // os.homedir() === '/Users/arthur'
+ * tildify('/Users/arthur/.infra-kit/config.yml') // => '~/.infra-kit/config.yml'
+ */
+const tildify = (filePath: string): string => {
+  const home = os.homedir()
+
+  return filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath
+}
+
+/**
+ * `fs.access` reduced to a boolean, swallowing ENOENT.
+ *
+ * @example
+ * await fileExists('/etc/hosts') // => true
+ */
+const fileExists = async (filePath: string): Promise<boolean> => {
+  try {
+    await fs.access(filePath)
+
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Swap a resolved `.json` config path back to its legacy `.yml` sibling.
+ *
+ * @example
+ * legacyYmlPath('/repo/infra-kit.json') // => '/repo/infra-kit.yml'
+ */
+const legacyYmlPath = (jsonPath: string): string => {
+  return jsonPath.replace(/\.json$/, '.yml')
+}
+
+/**
+ * Convert any legacy `infra-kit.yml` config layers to `infra-kit.json` as part
+ * of `infra-kit init`. Best-effort and non-fatal: each merge-chain layer
+ * (project, user-global, user-project) is migrated independently, and a
+ * conflict (both `.yml` and `.json` present) or an invalid `.yml` warns and
+ * skips that layer rather than aborting init or touching the other layers.
+ * Idempotent — already-JSON layers are left untouched.
+ *
+ * @example
+ * await migrateLegacyConfig()
+ * // INFO: ✓ Migrated infra-kit.yml → infra-kit.json
+ * // (no output when there is nothing legacy to convert)
+ */
+export const migrateLegacyConfig = async (): Promise<void> => {
+  let paths: Awaited<ReturnType<typeof getInfraKitConfigPaths>>
+
+  try {
+    paths = await getInfraKitConfigPaths()
+  } catch {
+    // No resolvable project (e.g. init run outside a repo) — nothing to migrate.
+    return
+  }
+
+  const layers: MigrateLayer[] = [
+    { label: 'infra-kit.json', yml: legacyYmlPath(paths.main), json: paths.main, schema: infraKitConfigSchema },
+    {
+      label: '~/.infra-kit/config.json',
+      yml: legacyYmlPath(paths.userGlobal),
+      json: paths.userGlobal,
+      schema: infraKitOverrideConfigSchema,
+    },
+    {
+      label: `~/.infra-kit/projects/${paths.projectName}/infra-kit.json`,
+      yml: legacyYmlPath(paths.userProject),
+      json: paths.userProject,
+      schema: infraKitOverrideConfigSchema,
+    },
+  ]
+
+  let migrated = 0
+
+  for (const layer of layers) {
+    const [ymlExists, jsonExists] = await Promise.all([fileExists(layer.yml), fileExists(layer.json)])
+
+    if (!ymlExists) continue
+
+    if (jsonExists) {
+      logger.info(
+        `⚠ Skipped ${tildify(layer.yml)} — ${tildify(layer.json)} already exists (remove the stale .yml manually)`,
+      )
+
+      continue
+    }
+
+    // Keep per-layer migration non-fatal even for malformed YAML or I/O errors
+    // (TOCTOU after the existence probe, EACCES, read-only FS): warn and skip
+    // so one bad layer never aborts `init` or the other layers.
+    try {
+      const raw = await fs.readFile(layer.yml, 'utf-8')
+      const parsed = (yaml.parse(raw) ?? {}) as unknown
+      const result = layer.schema.safeParse(parsed)
+
+      if (!result.success) {
+        logger.info(`⚠ Skipped ${tildify(layer.yml)} — invalid config: ${z.prettifyError(result.error)}`)
+
+        continue
+      }
+
+      await fs.mkdir(path.dirname(layer.json), { recursive: true })
+      await fs.writeFile(layer.json, `${JSON.stringify(result.data, null, 2)}\n`, 'utf-8')
+      await fs.rm(layer.yml, { force: true })
+
+      logger.info(`✓ Migrated ${tildify(layer.yml)} → ${tildify(layer.json)}`)
+      migrated++
+    } catch (err) {
+      logger.info(`⚠ Skipped ${tildify(layer.yml)} — ${(err as Error).message}`)
+    }
+  }
+
+  if (migrated > 0) {
+    resetInfraKitConfigCache()
+  }
+}

package/src/commands/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.8","results":[[":audit/__tests__/audit.test.ts",{"duration":0,"failed":true}]]}

package/src/commands/release-create/__tests__/release-create.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest'
+import type { z } from 'zod'
+
+import { releaseCreateMcpTool } from '../release-create'
+
+/**
+ * The MCP `releases[]` entry schema enforces that exactly one of `version` or
+ * `name` is supplied, and transforms each entry into the internal ReleaseInput
+ * shape. We exercise the schema directly (the array element) so we do not need
+ * to run the full handler (which performs git/Jira side effects).
+ */
+const entrySchema = (releaseCreateMcpTool.inputSchema.releases as z.ZodArray<z.ZodTypeAny>).element
+
+describe('release-create MCP releases[] entry schema', () => {
+  it('accepts a versioned entry and transforms it into a version ReleaseInput', () => {
+    expect(entrySchema.parse({ version: '1.2.5', type: 'hotfix' })).toEqual({
+      version: '1.2.5',
+      type: 'hotfix',
+    })
+  })
+
+  it('defaults type to regular', () => {
+    expect(entrySchema.parse({ version: '1.2.5' })).toEqual({
+      version: '1.2.5',
+      type: 'regular',
+    })
+  })
+
+  it('accepts a named entry and transforms it into a name ReleaseInput', () => {
+    expect(entrySchema.parse({ name: 'checkout-redesign', type: 'regular' })).toEqual({
+      name: 'checkout-redesign',
+      type: 'regular',
+    })
+  })
+
+  it('carries description through for named entries', () => {
+    expect(entrySchema.parse({ name: 'checkout-redesign', description: 'Q3' })).toEqual({
+      name: 'checkout-redesign',
+      type: 'regular',
+      description: 'Q3',
+    })
+  })
+
+  it('rejects an entry with both version and name (mutually exclusive)', () => {
+    expect(() => {
+      return entrySchema.parse({ version: '1.2.5', name: 'checkout-redesign' })
+    }).toThrow(/exactly one of/)
+  })
+
+  it('rejects an entry with neither version nor name', () => {
+    expect(() => {
+      return entrySchema.parse({ type: 'regular' })
+    }).toThrow(/exactly one of/)
+  })
+})