orizu 0.3.7 → 0.4.1

package/src/workspace.ts

@@ -0,0 +1,112 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
+import { join, resolve } from 'path'
+
+export const WORKSPACE_DIR_NAME = '.orizu'
+
+export interface WorkspaceInitOptions {
+  cwd?: string
+  baseUrl?: string | null
+  cliVersion?: string | null
+  dryRun?: boolean
+}
+
+export interface WorkspaceInitResult {
+  root: string
+  state: 'created' | 'exists' | 'would-create'
+  gitignoreUpdated: boolean
+  actions: string[]
+}
+
+const WORKSPACE_README = `# Orizu workspace
+
+Local Orizu artifacts for this repository. This folder is gitignored by
+default: generated and server-derived content here is not guaranteed to stay
+in sync with the Orizu server, so checking it in would risk drift. Safe,
+user-authored configuration may move to a committed location once a sync model
+exists.
+
+- \`workspace.json\`: safe local metadata (no secrets; credentials stay in
+  \`~/.config/orizu\`).
+- \`generated/\`: runner artifacts, exports, and other generated files.
+`
+
+export function getWorkspaceRoot(cwd?: string): string {
+  return resolve(cwd || process.cwd(), WORKSPACE_DIR_NAME)
+}
+
+export function workspaceExists(cwd?: string): boolean {
+  return existsSync(join(getWorkspaceRoot(cwd), 'workspace.json'))
+}
+
+function ensureGitignoreEntry(cwd: string, dryRun: boolean): { updated: boolean, action: string | null } {
+  const gitignorePath = resolve(cwd, '.gitignore')
+  const entry = `${WORKSPACE_DIR_NAME}/`
+
+  if (existsSync(gitignorePath)) {
+    const existing = readFileSync(gitignorePath, 'utf8')
+    const hasEntry = existing
+      .split('\n')
+      .some(line => line.trim() === entry || line.trim() === WORKSPACE_DIR_NAME)
+    if (hasEntry) {
+      return { updated: false, action: null }
+    }
+    if (!dryRun) {
+      const separator = existing.endsWith('\n') || existing.length === 0 ? '' : '\n'
+      writeFileSync(gitignorePath, `${existing}${separator}\n# Local Orizu workspace (generated; not synced with the server)\n${entry}\n`, 'utf8')
+    }
+    return { updated: true, action: `append ${entry} to .gitignore` }
+  }
+
+  if (!dryRun) {
+    writeFileSync(gitignorePath, `# Local Orizu workspace (generated; not synced with the server)\n${entry}\n`, 'utf8')
+  }
+  return { updated: true, action: `create .gitignore with ${entry}` }
+}
+
+export function initOrizuWorkspace(options?: WorkspaceInitOptions): WorkspaceInitResult {
+  const cwd = resolve(options?.cwd || process.cwd())
+  const root = getWorkspaceRoot(cwd)
+  const dryRun = Boolean(options?.dryRun)
+  const exists = workspaceExists(cwd)
+  const actions: string[] = []
+
+  if (!exists) {
+    actions.push(`create ${WORKSPACE_DIR_NAME}/workspace.json, README.md, and generated/`)
+  }
+
+  const gitignore = ensureGitignoreEntry(cwd, dryRun || exists)
+  if (!exists && gitignore.action) {
+    actions.push(gitignore.action)
+  }
+
+  if (dryRun) {
+    return {
+      root,
+      state: exists ? 'exists' : 'would-create',
+      gitignoreUpdated: false,
+      actions,
+    }
+  }
+
+  if (exists) {
+    return { root, state: 'exists', gitignoreUpdated: false, actions: [] }
+  }
+
+  mkdirSync(join(root, 'generated'), { recursive: true })
+  writeFileSync(join(root, 'README.md'), WORKSPACE_README, 'utf8')
+  writeFileSync(
+    join(root, 'workspace.json'),
+    `${JSON.stringify(
+      {
+        version: 1,
+        server: options?.baseUrl || null,
+        createdByCliVersion: options?.cliVersion || null,
+      },
+      null,
+      2
+    )}\n`,
+    'utf8'
+  )
+
+  return { root, state: 'created', gitignoreUpdated: gitignore.updated, actions }
+}

package/vendor/orizu-gepa-python/src/orizu_gepa/__init__.py

@@ -3,6 +3,7 @@ from .optimizer import (
     DatasetRow,
     NumThreadsPlan,
     PromptContext,
+    RetryableReflectionError,
     RowEvaluation,
     TextGepaConfig,
     TextGepaResult,
@@ -15,6 +16,7 @@ __all__ = [
     "DatasetRow",
     "NumThreadsPlan",
     "PromptContext",
+    "RetryableReflectionError",
     "RowEvaluation",
     "TextGepaConfig",
     "TextGepaResult",

package/vendor/orizu-gepa-python/src/orizu_gepa/cli.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import sys
 from pathlib import Path
 from typing import Any
 
@@ -11,6 +12,8 @@ from .optimizer import TextGepaConfig, optimize_loaded_text_candidate
 from .reflection import reflect_with_provider
 from .runner import make_candidate_runner, make_scorer_runner
 
+BUDGET_OPTION_FLAGS = ("--budget", "--max-metric-calls", "--max-full-evals", "--max-iterations")
+
 
 def positive_int(value: str) -> int:
     parsed = int(value)
@@ -46,6 +49,38 @@ def read_json_object_arg(value: str | None, flag_name: str) -> dict[str, Any] |
     return parsed
 
 
+def _flag_occurrences(raw_args: list[str], flag: str) -> int:
+    return sum(1 for arg in raw_args if arg == flag or arg.startswith(f"{flag}="))
+
+
+def _format_budget_option(flag: str, count: int) -> str:
+    return flag if count == 1 else f"{flag} ({count} times)"
+
+
+def apply_budget_defaults(args: argparse.Namespace, raw_args: list[str]) -> None:
+    occurrences = {
+        flag: _flag_occurrences(raw_args, flag)
+        for flag in BUDGET_OPTION_FLAGS
+    }
+    provided = [
+        _format_budget_option(flag, count)
+        for flag, count in occurrences.items()
+        if count > 0
+    ]
+    total = sum(occurrences.values())
+
+    if total > 1:
+        allowed = ", ".join(BUDGET_OPTION_FLAGS)
+        received = ", ".join(provided)
+        raise ValueError(
+            f"Budget options are mutually exclusive; choose at most one of {allowed}. "
+            f"Received: {received}."
+        )
+
+    if total == 0:
+        args.budget = TextGepaConfig.budget
+
+
 def main() -> None:
     parser = argparse.ArgumentParser(prog="orizu-gepa")
     parser.add_argument("--project", required=True)
@@ -60,8 +95,8 @@ def main() -> None:
     parser.add_argument("--split-set-id", required=True)
     parser.add_argument("--train-split", default="train")
     parser.add_argument("--val-split", default="validation")
-    parser.add_argument("--budget", default="light", choices=["auto", "light", "medium", "heavy"])
-    parser.add_argument("--max-iterations", type=positive_int, default=3)
+    parser.add_argument("--budget", choices=["auto", "light", "medium", "heavy"])
+    parser.add_argument("--max-iterations", type=positive_int)
     parser.add_argument("--minibatch-size", type=positive_int, default=3)
     parser.add_argument("--num-threads", type=num_threads_arg, default=TextGepaConfig.num_threads)
     parser.add_argument(
@@ -76,6 +111,18 @@ def main() -> None:
     parser.add_argument("--reflection-model", default=TextGepaConfig.reflection_model)
     parser.add_argument("--reflection-temperature", type=float)
     parser.add_argument("--reflection-max-tokens", type=positive_int)
+    parser.add_argument(
+        "--reflection-retry-attempts",
+        type=positive_int,
+        default=TextGepaConfig.reflection_retry_attempts,
+        help="Total attempts for retryable reflection HTTP failures.",
+    )
+    parser.add_argument(
+        "--reflection-http-timeout-seconds",
+        type=positive_int,
+        default=TextGepaConfig.reflection_http_timeout_seconds,
+        help="Per-attempt timeout for reflection HTTP calls.",
+    )
     parser.add_argument("--reflection-prompt-template")
     parser.add_argument("--reflection-provider-settings")
     parser.add_argument(
@@ -99,7 +146,12 @@ def main() -> None:
     parser.add_argument("--log-dir", default="logs")
     parser.add_argument("--no-local-log", action="store_true")
     parser.add_argument("--metadata", default="{}")
-    args = parser.parse_args()
+    raw_args = sys.argv[1:]
+    args = parser.parse_args(raw_args)
+    try:
+        apply_budget_defaults(args, raw_args)
+    except ValueError as error:
+        parser.error(str(error))
 
     metadata = json.loads(args.metadata)
     if not isinstance(metadata, dict):
@@ -117,6 +169,8 @@ def main() -> None:
         reflection_model=args.reflection_model,
         reflection_temperature=args.reflection_temperature,
         reflection_max_tokens=args.reflection_max_tokens,
+        reflection_retry_attempts=args.reflection_retry_attempts,
+        reflection_http_timeout_seconds=args.reflection_http_timeout_seconds,
         reflection_prompt_template=read_text_arg(args.reflection_prompt_template),
         reflection_provider_settings=read_json_object_arg(args.reflection_provider_settings, "--reflection-provider-settings") or {},
         skip_perfect_parent_reflection=args.skip_perfect_parent_reflection,

package/vendor/orizu-gepa-python/src/orizu_gepa/client.py

@@ -12,6 +12,39 @@ from typing import Any
 from .optimizer import DatasetRow, PromptContext
 
 
+def _format_number(value: Any) -> str | None:
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, float):
+        return f"{value:g}"
+    return None
+
+
+def _progress_log_suffix(event_type: str, payload: dict[str, Any] | None) -> str:
+    if event_type != "optimization_progress" or not isinstance(payload, dict):
+        return ""
+
+    percent_value = payload.get("percent")
+    if percent_value is None:
+        percent_value = payload.get("progress_percent")
+    percent = _format_number(percent_value)
+    metric_calls_remaining = _format_number(payload.get("metric_calls_remaining"))
+    metric_call_budget_value = payload.get("metric_call_budget")
+    if metric_call_budget_value is None:
+        metric_call_budget_value = payload.get("approx_metric_call_budget")
+    metric_call_budget = _format_number(metric_call_budget_value)
+    parts: list[str] = []
+    if percent is not None:
+        parts.append(f"{percent}%")
+    if metric_calls_remaining is not None:
+        budget_suffix = f" / {metric_call_budget}" if metric_call_budget is not None else ""
+        parts.append(f"{metric_calls_remaining}{budget_suffix} metric calls left")
+
+    return f" {'; '.join(parts)}" if parts else ""
+
+
 @dataclass(frozen=True)
 class OrizuClient:
     api_url: str
@@ -306,7 +339,10 @@ class OrizuEventSink:
                     parent_candidate_id=parent_candidate_id,
                     child_candidate_id=child_candidate_id,
                 )
-                print(f"[orizu-gepa] {self.sequence:03d} {event_type}", flush=True)
+                print(
+                    f"[orizu-gepa] {self.sequence:03d} {event_type}{_progress_log_suffix(event_type, payload)}",
+                    flush=True,
+                )
                 return
             except Exception as exc:
                 last_error = exc