orizu 0.5.19 → 0.5.21

package/src/prompt-label-cli.ts

@@ -0,0 +1,55 @@
+import { authedFetch } from './http.js'
+import { parseJsonResponse, sanitizeTerminalText } from './json-response.js'
+
+interface PromptLabelCliContext {
+  getArg: (name: string) => string | null
+  getPositionalArg: (index: number) => string | null
+  json: boolean
+  printJson: (value: Record<string, unknown>) => void
+  printLine: (value: string) => void
+  resolveProjectSlug: (project: string | null) => Promise<string>
+}
+
+interface PromptLabelResponse {
+  prompt_id: string
+  prompt_version_id: string
+  label: string
+  owner?: {
+    instructionSetSlug: string
+    componentKey: string
+  } | null
+}
+
+export async function setPromptLabel(context: PromptLabelCliContext): Promise<void> {
+  const promptName = context.getPositionalArg(3)
+  const label = context.getPositionalArg(4)
+  const project = context.getArg('--project') || await context.resolveProjectSlug(null)
+  const promptVersionId = context.getArg('--version')
+
+  if (!promptName || !label || !promptVersionId) {
+    throw new Error('Usage: orizu prompts labels set <prompt-name> <label> --version <prompt-version-id> [--project <team/project>] [--json]')
+  }
+
+  const response = await authedFetch(`/api/cli/prompts/labels?project=${encodeURIComponent(project)}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ promptName, label, promptVersionId }),
+  })
+  if (!response.ok) {
+    throw new Error(`Failed to set prompt label: ${await response.text()}`)
+  }
+
+  const data = await parseJsonResponse<PromptLabelResponse>(response, 'Prompt label set')
+  if (context.json) {
+    context.printJson(data as unknown as Record<string, unknown>)
+    return
+  }
+
+  context.printLine(`Moved ${sanitizeTerminalText(label)} to ${sanitizeTerminalText(promptVersionId)}`)
+  if (data.owner) {
+    context.printLine(
+      `Owner: ${sanitizeTerminalText(promptName)} (${sanitizeTerminalText(data.prompt_id)}) -> ` +
+      `${sanitizeTerminalText(data.owner.instructionSetSlug)} / ${sanitizeTerminalText(data.owner.componentKey)}`
+    )
+  }
+}

package/src/prompt-length-wire.ts

@@ -56,9 +56,9 @@ export function formatFiniteLengthCount(
   signed = false
 ): string | null {
   if (typeof value !== 'number' || !Number.isFinite(value)) return null
+  if (!signed) return value.toLocaleString('en-US')
 
   const formatted = Math.abs(value).toLocaleString('en-US')
-  if (!signed) return formatted
   if (value > 0) return `+${formatted}`
   if (value < 0) return `-${formatted}`
   return formatted

package/src/prompt-report-cli.ts

@@ -59,7 +59,7 @@ export async function promptReportCommand(
 
   if (!prompt) {
     throw new Error(
-      'Usage: orizu prompts report set --prompt <id-or-name> --project <team/project> ' +
+      'Usage: orizu prompts report set --prompt <id-or-name> [--project <team/project>] ' +
       '(--version <n> | --version-id <id>) ' +
       '(--report <markdown|@file> | --report-file <path>) [--json]'
     )
@@ -74,7 +74,7 @@ export async function promptReportCommand(
   const report = readMarkdownReportInput(args, 'Prompt')
   if (!report) {
     throw new Error(
-      'Usage: orizu prompts report set --prompt <id-or-name> --project <team/project> ' +
+      'Usage: orizu prompts report set --prompt <id-or-name> [--project <team/project>] ' +
       '(--version <n> | --version-id <id>) ' +
       '(--report <markdown|@file> | --report-file <path>) [--json]'
     )

package/src/prompt-summary-table.ts

@@ -10,6 +10,10 @@ interface PromptSummaryRow {
   role: string
   status?: string
   lengthStats?: CliLengthStats | null
+  owner?: {
+    instructionSetSlug: string
+    componentKey: string
+  } | null
 }
 
 export function printPromptSummaryTable(
@@ -54,4 +58,12 @@ export function printPromptSummaryTable(
   rows.forEach(row => {
     printLine(keys.map((key, index) => row[key].padEnd(widths[index])).join('  '))
   })
+  items.forEach(item => {
+    if (item.owner) {
+      printLine(
+        `Owner: ${sanitizeTerminalText(item.name)} (${sanitizeTerminalText(item.id)}) -> ` +
+        `${sanitizeTerminalText(item.owner.instructionSetSlug)} / ${sanitizeTerminalText(item.owner.componentKey)}`
+      )
+    }
+  })
 }

package/src/report-markdown-blankness.ts

@@ -0,0 +1,6 @@
+// JavaScript's \s is broader than the database locale's POSIX [:space:]
+// predicate. These four code points are content in the measured PostgreSQL
+// boundary, so retain them explicitly when validating CLI report input.
+export function hasCanonicalReportMarkdownContent(markdown: string): boolean {
+  return /(?:[^\s]|[\u00a0\u2007\u202f\ufeff])/u.test(markdown)
+}

package/src/report-replacement-warning.ts

@@ -0,0 +1,35 @@
+/**
+ * ALI-1452: a shared, human-readable warning for a replaced prompt-version
+ * report on a push/draft response.
+ *
+ * Re-pushing an unchanged prompt with a report deliberately replaces the
+ * version's existing report (reports are correctable; versions are immutable).
+ * The server discloses that replacement as `report_replaced:
+ * { source_name, updated_at } | null`; this turns a non-null disclosure into
+ * the stderr warning line the push commands print. JSON mode prints nothing —
+ * the payload already carries `report_replaced`.
+ */
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+/**
+ * A one-line warning when a push response discloses that it replaced an
+ * existing report, or null when nothing was replaced (or no report was sent).
+ */
+export function reportReplacementWarning(data: Record<string, unknown>): string | null {
+  const replaced = data.report_replaced
+  if (!isRecord(replaced)) return null
+
+  const sourceName = typeof replaced.source_name === 'string'
+    ? replaced.source_name
+    : 'unknown source'
+  const updatedAt = typeof replaced.updated_at === 'string'
+    ? replaced.updated_at
+    : 'unknown time'
+  return (
+    'Warning: replaced the existing report for this version ' +
+    `(${sourceName}, last updated ${updatedAt})`
+  )
+}

package/src/runner-instruction-set-contract.ts

@@ -0,0 +1,64 @@
+import { type SyncComponent, type SyncSet } from './instruction-sets-cli.js'
+
+export interface RunnerInstructionSet {
+  name: string
+  modelConfig: Record<string, unknown>
+  shape: string[]
+  profileVersionId: string
+  modelConfigSettingsVersionId?: string
+  versionNumber: number
+  promptComponentKey?: string
+  components: Record<string, string>
+  pinnedComponents?: Record<string, { repoPath: string; contentSha: string; commitSha: string }>
+}
+
+export function runnerInstructionSetSyncSet(instructionSet: RunnerInstructionSet): SyncSet {
+  const modelConfigIdentity = typeof instructionSet.modelConfig.identity === 'string'
+    ? instructionSet.modelConfig.identity
+    : ''
+  if (!modelConfigIdentity) throw new Error('Runner exec context instruction set has no model config identity')
+  const missingKey = instructionSet.shape.find(key => !(key in instructionSet.components) && !(key in (instructionSet.pinnedComponents || {})))
+  if (missingKey) throw new Error('instruction_set_tuple_incomplete')
+  const components: Record<string, SyncComponent> = Object.fromEntries(Object.entries(instructionSet.components).map(([key, body]) => [key, { body }]))
+  for (const [key, pin] of Object.entries(instructionSet.pinnedComponents || {})) components[key] = pin
+  const material = {
+    profileVersionId: instructionSet.profileVersionId,
+    versionNumber: instructionSet.versionNumber,
+    modelConfigIdentity,
+    // syncToDisk's long-lived manifest requires provenance; this execution
+    // path has no resolver decision to expose, only an exact profile version.
+    resolvedFrom: 'exact_profile_version',
+    components,
+  }
+  return {
+    name: instructionSet.name,
+    shape: instructionSet.shape,
+    default: material,
+    profiles: [{ modelConfigIdentity, resolvedFrom: 'exact_profile_version', production: material }],
+  }
+}
+
+export function runnerInputPrompt(
+  promptContext: { body?: string | null; bodyKind: string; providerSettings: Record<string, unknown> }
+): Record<string, unknown> {
+  const prompt = {
+    body_kind: promptContext.bodyKind,
+    provider_settings: promptContext.providerSettings,
+  } as Record<string, unknown>
+  // The route owns this decision. Preserve its response shape exactly so an
+  // implicit wrapped prompt remains compatible with existing runners.
+  if ('body' in promptContext) prompt.body = promptContext.body
+  return prompt
+}
+
+export function runnerInputInstructionSet(instructionSet: RunnerInstructionSet): Record<string, unknown> {
+  return {
+    name: instructionSet.name,
+    model_config: instructionSet.modelConfig,
+    shape: instructionSet.shape,
+    ...(instructionSet.modelConfigSettingsVersionId ? { model_config_settings_version_id: instructionSet.modelConfigSettingsVersionId } : {}),
+    ...(instructionSet.promptComponentKey ? { prompt_component_key: instructionSet.promptComponentKey } : {}),
+    components: instructionSet.components,
+    ...(Object.keys(instructionSet.pinnedComponents || {}).length > 0 ? { pinned_components: instructionSet.pinnedComponents } : {}),
+  }
+}

package/src/scorers-cli.ts

@@ -0,0 +1,40 @@
+/**
+ * The `orizu scorers` subcommand router (ALI-1554).
+ *
+ * The five historical branches lived inline in index.ts; folding them here
+ * reclaims the headroom the CLI line ratchet (ALI-976) requires before a new
+ * subcommand may be added. Behaviour is unchanged: each handler is the same
+ * function index.ts already called, and an unrecognised subcommand returns
+ * null so main() still falls through to printUsage().
+ */
+export interface ScorersCommandIo {
+  list: () => Promise<void>
+  register: () => Promise<void>
+  detail: () => Promise<void>
+  labelsSet: () => Promise<void>
+  exec: () => Promise<void>
+  verifyParity: (args: string[]) => Promise<number>
+}
+
+/** Returns the process exit code, or null when the subcommand is not ours. */
+export async function scorersCommand(args: string[], io: ScorersCommandIo): Promise<number | null> {
+  const subcommand = args[1]
+  // A Map, not an object literal: `scorers constructor` must not resolve to
+  // an Object.prototype member and be treated as a known subcommand.
+  const handlers = new Map<string, () => Promise<void>>([
+    ['list', io.list], ['register', io.register], ['detail', io.detail], ['exec', io.exec],
+  ])
+  const handler = subcommand === undefined ? undefined : handlers.get(subcommand)
+  if (handler) {
+    await handler()
+    return 0
+  }
+  if (subcommand === 'labels' && args[2] === 'set') {
+    await io.labelsSet()
+    return 0
+  }
+  if (subcommand === 'verify-parity') {
+    return io.verifyParity(args.slice(2))
+  }
+  return null
+}

package/src/scorers-verify-parity-bridge.ts

@@ -0,0 +1,90 @@
+/**
+ * The customer-side half of `orizu scorers verify-parity` (ALI-1554).
+ *
+ * Embedded as a string constant and written to a temp file at run time on
+ * purpose: no packaging (`files`/`vendor`) change, so there is nothing for the
+ * published tarball to lose. It runs in the CUSTOMER's interpreter and the
+ * customer's unscrubbed environment — it is their metric in their process.
+ *
+ * Contract: reads `{rows: [{row_id, row, model_output}]}` from
+ * ORIZU_PARITY_INPUT_PATH, calls `<module>:<function>(row, model_output)` per
+ * row, and writes `{scores: [{row_id, score} | {row_id, error}]}` to
+ * ORIZU_PARITY_OUTPUT_PATH. Exit 2 (with the reason on stderr) means the check
+ * could not run at all; a per-row exception is that row's error, not an abort.
+ */
+export const PARITY_BRIDGE_SOURCE = `import json, math, os, sys, traceback
+
+
+def fail(message):
+    sys.stderr.write(message + "\\n")
+    sys.exit(2)
+
+
+def last_line(text):
+    lines = [line for line in text.strip().splitlines() if line.strip()]
+    return lines[-1] if lines else "unknown error"
+
+
+def extract(value):
+    # Mirrors orizu_gepa.optimizer._score_from_scorer, minus the clamp: the
+    # CLI clamps both sides so the compared number is what GEPA optimizes.
+    # bool is deliberately NOT rejected: measured, _score_from_scorer(extra=
+    # {'score': True}) -> (1.0, None) and False -> (0.0, None), because bool is an
+    # int subclass and Python's numeric branch accepts it. An exact-match DSPy
+    # metric returning True must compare, not error.
+    if isinstance(value, (int, float)):
+        raw = value
+    elif isinstance(value, dict):
+        raw = value.get("score")
+        if raw is None and isinstance(value.get("model_response"), dict):
+            raw = value["model_response"].get("score")
+    elif hasattr(value, "score"):
+        # official GEPA's EvaluationResult NamedTuple and friends;
+        # objective_scores is deliberately ignored.
+        raw = value.score
+    else:
+        raise TypeError("scorer result must be a number, a dict with a numeric 'score', or an object with a numeric .score attribute")
+    if isinstance(raw, str):
+        raw = float(raw)
+    if not isinstance(raw, (int, float)):
+        raise TypeError("scorer result must include a numeric score")
+    raw = float(raw)
+    if not math.isfinite(raw):
+        raise ValueError("scorer result score must be finite")
+    return raw
+
+
+target = os.environ.get("ORIZU_PARITY_ORIGINAL", "")
+module_name, separator, function_name = target.partition(":")
+if not separator or not module_name or not function_name:
+    fail("--original must be <module>:<function> (got %r)" % target)
+
+# The customer's metric lives beside the command's cwd, not beside this
+# generated bridge file, so cwd must win over the script directory.
+sys.path.insert(0, os.getcwd())
+try:
+    import importlib
+
+    module = importlib.import_module(module_name)
+except Exception:
+    fail("Failed to import original metric module '%s': %s" % (module_name, last_line(traceback.format_exc())))
+
+if not hasattr(module, function_name):
+    fail("Original metric module '%s' has no attribute '%s'" % (module_name, function_name))
+metric = getattr(module, function_name)
+if not callable(metric):
+    fail("Original metric '%s:%s' is not callable" % (module_name, function_name))
+
+with open(os.environ["ORIZU_PARITY_INPUT_PATH"], encoding="utf-8") as handle:
+    payload = json.load(handle)
+
+scores = []
+for item in payload["rows"]:
+    try:
+        scores.append({"row_id": item["row_id"], "score": extract(metric(item["row"], item["model_output"]))})
+    except Exception:
+        scores.append({"row_id": item["row_id"], "error": last_line(traceback.format_exc())})
+
+with open(os.environ["ORIZU_PARITY_OUTPUT_PATH"], "w", encoding="utf-8") as handle:
+    json.dump({"scores": scores}, handle)
+`