issue-flow 0.9.0 → 0.11.0

package/dist/{chunk-57MH6RYJ.js → chunk-HC2MT7BX.js}

@@ -1,16 +1,82 @@
 #!/usr/bin/env node
 
-// src/schemas.ts
+// src/policy/schemas.ts
 import { z } from "zod";
-var claudeUsageSchema = z.object({
-  inputTokens: z.number().optional(),
-  outputTokens: z.number().optional(),
-  cacheReadTokens: z.number().optional(),
-  cacheCreationTokens: z.number().optional(),
-  costUsd: z.number().optional()
+var policyDiscoveryConfigSchema = z.object({
+  issueTemplates: z.boolean().default(true),
+  pullRequestTemplate: z.boolean().default(true),
+  docs: z.boolean().default(true),
+  codeowners: z.boolean().default(true),
+  labels: z.boolean().default(true),
+  issueTypes: z.boolean().default(true)
+});
+var policyIssuesDeclarationSchema = z.object({
+  titleConvention: z.string().min(1).optional(),
+  /**
+   * Whether Issue Flow may create a label the repository does not have.
+   *
+   * `.optional()` rather than `.default(false)`: the resolved declarations must
+   * stay "only what was written", or the group would always look declared and
+   * `sources` would report a provenance nobody asked for. The effective default
+   * — false — lives at the call site.
+   *
+   * That default is a deliberate change of behaviour: creating taxonomy without
+   * asking is the defect this exists to stop. A repository that wants the old
+   * behaviour opts back into it.
+   */
+  allowLabelCreation: z.boolean().optional()
+});
+var policyPullRequestsDeclarationSchema = z.object({
+  baseBranch: z.string().min(1).optional(),
+  titleConvention: z.string().min(1).optional()
+});
+var policyGitDeclarationSchema = z.object({
+  branchConvention: z.string().min(1).optional(),
+  commitConvention: z.string().min(1).optional()
+});
+var policyConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  /**
+   * Token budget for the `__REPO_POLICY__` projection. Sections above it are
+   * replaced whole by a pointer rather than truncated — see
+   * `policy/placeholders.ts`.
+   */
+  contextBudget: z.number().int().positive().default(1500),
+  discovery: policyDiscoveryConfigSchema.prefault({}),
+  issues: policyIssuesDeclarationSchema.prefault({}),
+  pullRequests: policyPullRequestsDeclarationSchema.prefault({}),
+  git: policyGitDeclarationSchema.prefault({})
+});
+var policyConfigInputSchema = z.object({
+  enabled: z.boolean().optional(),
+  contextBudget: z.number().int().positive().optional(),
+  // Spelled out rather than `policyDiscoveryConfigSchema.partial()`: in zod 4
+  // a `.default()` survives `.partial()`, so every toggle would come back
+  // materialized and the input layer would stop meaning "what the user wrote".
+  discovery: z.object({
+    issueTemplates: z.boolean().optional(),
+    pullRequestTemplate: z.boolean().optional(),
+    docs: z.boolean().optional(),
+    codeowners: z.boolean().optional(),
+    labels: z.boolean().optional(),
+    issueTypes: z.boolean().optional()
+  }).optional(),
+  issues: z.object({ titleConvention: z.string().nullish(), allowLabelCreation: z.boolean().optional() }).optional(),
+  pullRequests: z.object({ baseBranch: z.string().nullish(), titleConvention: z.string().nullish() }).optional(),
+  git: z.object({ branchConvention: z.string().nullish(), commitConvention: z.string().nullish() }).optional()
+});
+
+// src/schemas.ts
+import { z as z2 } from "zod";
+var claudeUsageSchema = z2.object({
+  inputTokens: z2.number().optional(),
+  outputTokens: z2.number().optional(),
+  cacheReadTokens: z2.number().optional(),
+  cacheCreationTokens: z2.number().optional(),
+  costUsd: z2.number().optional()
 });
-var userStoryStatusSchema = z.enum(["backlog", "in_progress", "in_review", "done"]);
-var storyStageSchema = z.enum([
+var userStoryStatusSchema = z2.enum(["backlog", "in_progress", "in_review", "done"]);
+var storyStageSchema = z2.enum([
   "pending",
   "executing",
   "awaiting_review",
@@ -19,195 +85,195 @@ var storyStageSchema = z.enum([
   "done",
   "failed"
 ]);
-var userStorySchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  description: z.string(),
-  acceptanceCriteria: z.array(z.string()),
-  priority: z.number().int().positive(),
-  passes: z.boolean(),
-  notes: z.string(),
+var userStorySchema = z2.object({
+  id: z2.string(),
+  title: z2.string(),
+  description: z2.string(),
+  acceptanceCriteria: z2.array(z2.string()),
+  priority: z2.number().int().positive(),
+  passes: z2.boolean(),
+  notes: z2.string(),
   ...claudeUsageSchema.shape,
-  durationSeconds: z.number().optional(),
+  durationSeconds: z2.number().optional(),
   status: userStoryStatusSchema.optional(),
-  dependencies: z.array(z.string()).optional(),
+  dependencies: z2.array(z2.string()).optional(),
   stage: storyStageSchema.optional(),
-  stageSince: z.string().optional(),
-  stageDetail: z.string().optional()
+  stageSince: z2.string().optional(),
+  stageDetail: z2.string().optional()
 });
-var pipelineStateSchema = z.object({
-  analyzeCompleted: z.boolean().optional(),
-  prdCompleted: z.boolean(),
-  jsonCompleted: z.boolean(),
-  executionCompleted: z.boolean(),
-  reviewCompleted: z.boolean(),
-  prCreated: z.boolean(),
-  prReviewCompleted: z.boolean().optional()
+var pipelineStateSchema = z2.object({
+  analyzeCompleted: z2.boolean().optional(),
+  prdCompleted: z2.boolean(),
+  jsonCompleted: z2.boolean(),
+  executionCompleted: z2.boolean(),
+  reviewCompleted: z2.boolean(),
+  prCreated: z2.boolean(),
+  prReviewCompleted: z2.boolean().optional()
 });
-var pullRequestRefSchema = z.object({
-  number: z.number().int().positive(),
-  url: z.string(),
-  headBranch: z.string(),
-  createdAt: z.string()
+var pullRequestRefSchema = z2.object({
+  number: z2.number().int().positive(),
+  url: z2.string(),
+  headBranch: z2.string(),
+  createdAt: z2.string()
 });
-var prReviewRecommendationSchema = z.enum([
+var prReviewRecommendationSchema = z2.enum([
   "APPROVE",
   "APPROVE_WITH_SUGGESTIONS",
   "REQUEST_CHANGES"
 ]);
-var prReviewStateSchema = z.object({
-  enabled: z.boolean().default(false),
-  pullRequestNumber: z.number().int().positive().optional(),
-  rounds: z.number().int().min(0).default(0),
+var prReviewStateSchema = z2.object({
+  enabled: z2.boolean().default(false),
+  pullRequestNumber: z2.number().int().positive().optional(),
+  rounds: z2.number().int().min(0).default(0),
   lastRecommendation: prReviewRecommendationSchema.optional(),
-  lastReviewedAt: z.string().optional()
+  lastReviewedAt: z2.string().optional()
 });
-var lastErrorSchema = z.object({
-  category: z.string(),
-  message: z.string(),
-  at: z.string()
+var lastErrorSchema = z2.object({
+  category: z2.string(),
+  message: z2.string(),
+  at: z2.string()
 });
-var issueMetadataSchema = z.object({
-  schemaVersion: z.literal(1),
-  id: z.string().min(1),
-  number: z.number().int().positive().nullable(),
-  source: z.enum(["github", "local"]),
-  title: z.string(),
-  labels: z.array(z.string()),
-  state: z.enum(["open", "closed"]),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-  contentHash: z.string(),
-  remote: z.object({
-    provider: z.enum(["github", "local"]),
-    ref: z.string(),
-    syncedAt: z.string(),
-    syncedContentHash: z.string()
+var issueMetadataSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  id: z2.string().min(1),
+  number: z2.number().int().positive().nullable(),
+  source: z2.enum(["github", "local"]),
+  title: z2.string(),
+  labels: z2.array(z2.string()),
+  state: z2.enum(["open", "closed"]),
+  createdAt: z2.string(),
+  updatedAt: z2.string(),
+  contentHash: z2.string(),
+  remote: z2.object({
+    provider: z2.enum(["github", "local"]),
+    ref: z2.string(),
+    syncedAt: z2.string(),
+    syncedContentHash: z2.string()
   }).optional()
 });
-var taskPlanSchema = z.object({
-  project: z.string(),
-  issueNumber: z.union([z.number().int().positive(), z.string().min(1)]),
-  issueUrl: z.string().optional().default(""),
-  branchName: z.string(),
-  noBranch: z.boolean().optional().default(false),
-  description: z.string(),
-  issueStatus: z.enum(["pending", "in_progress", "completed"]),
-  completedAt: z.string().nullable(),
-  lastAttemptAt: z.string().nullable(),
+var taskPlanSchema = z2.object({
+  project: z2.string(),
+  issueNumber: z2.union([z2.number().int().positive(), z2.string().min(1)]),
+  issueUrl: z2.string().optional().default(""),
+  branchName: z2.string(),
+  noBranch: z2.boolean().optional().default(false),
+  description: z2.string(),
+  issueStatus: z2.enum(["pending", "in_progress", "completed"]),
+  completedAt: z2.string().nullable(),
+  lastAttemptAt: z2.string().nullable(),
   lastError: lastErrorSchema.nullable(),
-  correctionCycle: z.number().int().min(0),
-  maxCorrectionCycles: z.number().int().min(0),
+  correctionCycle: z2.number().int().min(0),
+  maxCorrectionCycles: z2.number().int().min(0),
   /**
    * Findings from the most recent failed review, verbatim. Non-null means the
    * issue has a pending correction even if every userStories[].passes is
    * already true — the execute phase must address these before the field is
    * cleared back to null. See core/engine.ts's early-return guards.
    */
-  lastReviewFindings: z.string().nullable().optional().default(null),
+  lastReviewFindings: z2.string().nullable().optional().default(null),
   pipeline: pipelineStateSchema,
   pullRequest: pullRequestRefSchema.optional(),
   prReview: prReviewStateSchema.optional(),
-  userStories: z.array(userStorySchema)
+  userStories: z2.array(userStorySchema)
 });
-var headlessResultSchema = z.object({
-  success: z.boolean(),
-  result: z.string(),
+var headlessResultSchema = z2.object({
+  success: z2.boolean(),
+  result: z2.string(),
   cost: claudeUsageSchema.nullable(),
-  error: z.string().nullable()
+  error: z2.string().nullable()
 });
-var sessionLogEntrySchema = z.object({
-  at: z.string(),
-  level: z.enum(["info", "warn", "error"]),
-  message: z.string()
+var sessionLogEntrySchema = z2.object({
+  at: z2.string(),
+  level: z2.enum(["info", "warn", "error"]),
+  message: z2.string()
 });
 var sessionUsageShape = {
-  inputTokens: z.number().nullable().default(null),
-  outputTokens: z.number().nullable().default(null),
-  cacheReadTokens: z.number().nullable().default(null),
-  cacheCreationTokens: z.number().nullable().default(null),
-  costUsd: z.number().nullable().default(null)
+  inputTokens: z2.number().nullable().default(null),
+  outputTokens: z2.number().nullable().default(null),
+  cacheReadTokens: z2.number().nullable().default(null),
+  cacheCreationTokens: z2.number().nullable().default(null),
+  costUsd: z2.number().nullable().default(null)
 };
-var sessionPhaseSchema = z.object({
-  name: z.string(),
-  status: z.enum(["pending", "running", "completed", "failed"]),
-  startedAt: z.string().nullable(),
-  endedAt: z.string().nullable(),
-  durationSeconds: z.number().nullable(),
-  error: z.string().nullable(),
+var sessionPhaseSchema = z2.object({
+  name: z2.string(),
+  status: z2.enum(["pending", "running", "completed", "failed"]),
+  startedAt: z2.string().nullable(),
+  endedAt: z2.string().nullable(),
+  durationSeconds: z2.number().nullable(),
+  error: z2.string().nullable(),
   ...sessionUsageShape
 });
-var sessionStorySchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  priority: z.number(),
-  passes: z.boolean(),
-  completedAt: z.string().nullable(),
+var sessionStorySchema = z2.object({
+  id: z2.string(),
+  title: z2.string(),
+  priority: z2.number(),
+  passes: z2.boolean(),
+  completedAt: z2.string().nullable(),
   // Also introduced with the metrics, hence the same tolerant default.
-  durationSeconds: z.number().nullable().default(null),
+  durationSeconds: z2.number().nullable().default(null),
   // Snapshot fields are always present on output and defaulted on input, so a
   // session.json written before they existed still parses. This is the mirror
   // image of userStorySchema, where the same two fields are plainly optional.
   status: userStoryStatusSchema.default("backlog"),
-  dependencies: z.array(z.string()).default([]),
+  dependencies: z2.array(z2.string()).default([]),
   // Published for the panel's story detail view. Same tolerant default as the
   // fields above: absent (older session.json) and empty resolve to the same
   // value, so the client never has to tell them apart.
-  description: z.string().default(""),
-  acceptanceCriteria: z.array(z.string()).default([]),
+  description: z2.string().default(""),
+  acceptanceCriteria: z2.array(z2.string()).default([]),
   // Additive like the rest of this schema: a session.json written before
   // `stage` existed parses into 'pending'/null, the same values a fresh
   // snapshot starts a story at.
   stage: storyStageSchema.default("pending"),
-  stageSince: z.string().nullable().default(null),
-  stageDetail: z.string().nullable().default(null),
+  stageSince: z2.string().nullable().default(null),
+  stageDetail: z2.string().nullable().default(null),
   ...sessionUsageShape
 });
-var sessionSnapshotSchema = z.object({
-  schemaVersion: z.literal(1),
-  sessionId: z.string().nullable(),
-  readOnly: z.literal(true),
-  capabilities: z.array(z.string()),
-  issue: z.object({
-    number: z.number().nullable(),
-    url: z.string().nullable(),
+var sessionSnapshotSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  sessionId: z2.string().nullable(),
+  readOnly: z2.literal(true),
+  capabilities: z2.array(z2.string()),
+  issue: z2.object({
+    number: z2.number().nullable(),
+    url: z2.string().nullable(),
     // Additive: a session.json written before the Issue section was enriched
     // parses into the same "not reported" values createInitialSnapshot() uses.
-    title: z.string().nullable().default(null),
-    description: z.string().nullable().default(null),
-    labels: z.array(z.string()).default([]),
-    state: z.string().nullable().default(null)
+    title: z2.string().nullable().default(null),
+    description: z2.string().nullable().default(null),
+    labels: z2.array(z2.string()).default([]),
+    state: z2.string().nullable().default(null)
   }),
-  status: z.enum(["idle", "running", "completed", "failed"]),
-  startedAt: z.string().nullable(),
-  updatedAt: z.string().nullable(),
-  endedAt: z.string().nullable(),
-  elapsedSeconds: z.number().nullable(),
-  estimatedRemainingSeconds: z.number().nullable(),
-  progress: z.object({
-    percent: z.number(),
-    phasesCompleted: z.number(),
-    phasesTotal: z.number(),
-    storiesCompleted: z.number(),
-    storiesTotal: z.number()
+  status: z2.enum(["idle", "running", "completed", "failed"]),
+  startedAt: z2.string().nullable(),
+  updatedAt: z2.string().nullable(),
+  endedAt: z2.string().nullable(),
+  elapsedSeconds: z2.number().nullable(),
+  estimatedRemainingSeconds: z2.number().nullable(),
+  progress: z2.object({
+    percent: z2.number(),
+    phasesCompleted: z2.number(),
+    phasesTotal: z2.number(),
+    storiesCompleted: z2.number(),
+    storiesTotal: z2.number()
   }),
-  currentPhase: z.string().nullable(),
-  currentActivity: z.object({
-    story: z.string().nullable(),
-    tool: z.string().nullable(),
-    detail: z.string().nullable(),
-    since: z.string()
+  currentPhase: z2.string().nullable(),
+  currentActivity: z2.object({
+    story: z2.string().nullable(),
+    tool: z2.string().nullable(),
+    detail: z2.string().nullable(),
+    since: z2.string()
   }).nullable(),
-  phases: z.array(sessionPhaseSchema),
-  stories: z.array(sessionStorySchema),
+  phases: z2.array(sessionPhaseSchema),
+  stories: z2.array(sessionStorySchema),
   // The whole aggregate is additive: a snapshot from before it existed parses
   // into the same "nothing reported" object the reducer starts from.
-  metrics: z.object({
-    totalInputTokens: z.number().nullable().default(null),
-    totalOutputTokens: z.number().nullable().default(null),
-    totalCacheReadTokens: z.number().nullable().default(null),
-    totalCacheCreationTokens: z.number().nullable().default(null),
-    totalCostUsd: z.number().nullable().default(null)
+  metrics: z2.object({
+    totalInputTokens: z2.number().nullable().default(null),
+    totalOutputTokens: z2.number().nullable().default(null),
+    totalCacheReadTokens: z2.number().nullable().default(null),
+    totalCacheCreationTokens: z2.number().nullable().default(null),
+    totalCostUsd: z2.number().nullable().default(null)
   }).default({
     totalInputTokens: null,
     totalOutputTokens: null,
@@ -215,51 +281,51 @@ var sessionSnapshotSchema = z.object({
     totalCacheCreationTokens: null,
     totalCostUsd: null
   }),
-  execution: z.object({
-    iteration: z.number(),
-    retries: z.number(),
-    correctionCycle: z.number(),
-    maxCorrectionCycles: z.number().nullable()
+  execution: z2.object({
+    iteration: z2.number(),
+    retries: z2.number(),
+    correctionCycle: z2.number(),
+    maxCorrectionCycles: z2.number().nullable()
   }),
-  git: z.object({
-    branch: z.string().nullable(),
-    baseBranch: z.string().nullable(),
-    commits: z.array(z.object({ hash: z.string(), subject: z.string() }))
+  git: z2.object({
+    branch: z2.string().nullable(),
+    baseBranch: z2.string().nullable(),
+    commits: z2.array(z2.object({ hash: z2.string(), subject: z2.string() }))
   }),
   // Additive like the metrics aggregate: a session.json written before the
   // repository section existed parses into the same all-null object
   // createInitialSnapshot() starts from.
-  repository: z.object({
-    name: z.string().nullable().default(null),
-    remoteUrl: z.string().nullable().default(null),
-    branch: z.string().nullable().default(null),
-    headCommit: z.string().nullable().default(null),
-    root: z.string().nullable().default(null)
+  repository: z2.object({
+    name: z2.string().nullable().default(null),
+    remoteUrl: z2.string().nullable().default(null),
+    branch: z2.string().nullable().default(null),
+    headCommit: z2.string().nullable().default(null),
+    root: z2.string().nullable().default(null)
   }).default({ name: null, remoteUrl: null, branch: null, headCommit: null, root: null }),
-  pullRequests: z.array(z.object({ number: z.number(), url: z.string(), title: z.string() })),
-  logs: z.array(sessionLogEntrySchema),
-  errors: z.array(sessionLogEntrySchema),
-  warnings: z.array(sessionLogEntrySchema),
-  lastError: z.object({ message: z.string(), at: z.string() }).nullable(),
-  nextSteps: z.array(z.string()),
-  environment: z.object({ node: z.string(), platform: z.string() }).nullable()
+  pullRequests: z2.array(z2.object({ number: z2.number(), url: z2.string(), title: z2.string() })),
+  logs: z2.array(sessionLogEntrySchema),
+  errors: z2.array(sessionLogEntrySchema),
+  warnings: z2.array(sessionLogEntrySchema),
+  lastError: z2.object({ message: z2.string(), at: z2.string() }).nullable(),
+  nextSteps: z2.array(z2.string()),
+  environment: z2.object({ node: z2.string(), platform: z2.string() }).nullable()
 });
-var webConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  port: z.number().int().min(1).max(65535).default(3737),
-  host: z.string().min(1).default("0.0.0.0"),
-  refreshSeconds: z.number().positive().default(5),
-  logLimit: z.number().int().positive().default(200),
-  includeLogs: z.boolean().default(true)
+var webConfigSchema = z2.object({
+  enabled: z2.boolean().default(false),
+  port: z2.number().int().min(1).max(65535).default(3737),
+  host: z2.string().min(1).default("0.0.0.0"),
+  refreshSeconds: z2.number().positive().default(5),
+  logLimit: z2.number().int().positive().default(200),
+  includeLogs: z2.boolean().default(true)
 });
-var issuesConfigSchema = z.object({
-  defaultGenerateTarget: z.enum(["github", "local", "both"]).default("github"),
-  preferredProvider: z.enum(["github", "local"]).default("github"),
-  conflictPolicy: z.enum(["ask", "prefer-local", "prefer-github"]).default("ask"),
-  requireConfirmation: z.boolean().default(true)
+var issuesConfigSchema = z2.object({
+  defaultGenerateTarget: z2.enum(["github", "local", "both"]).default("github"),
+  preferredProvider: z2.enum(["github", "local"]).default("github"),
+  conflictPolicy: z2.enum(["ask", "prefer-local", "prefer-github"]).default("ask"),
+  requireConfirmation: z2.boolean().default(true)
 });
-var prReviewConfigSchema = z.object({
-  publisher: z.enum(["local"]).default("local")
+var prReviewConfigSchema = z2.object({
+  publisher: z2.enum(["local"]).default("local")
 });
 
 // src/core/session-state.ts
@@ -1259,6 +1325,8 @@ var ElapsedTimer = class {
 };
 
 export {
+  policyConfigSchema,
+  policyConfigInputSchema,
   pullRequestRefSchema,
   issueMetadataSchema,
   taskPlanSchema,
@@ -1312,4 +1380,4 @@ export {
   formatDuration,
   ElapsedTimer
 };
-//# sourceMappingURL=chunk-57MH6RYJ.js.map
+//# sourceMappingURL=chunk-HC2MT7BX.js.map