orizu 0.3.5 → 0.3.7

package/src/skill-installer.ts

@@ -0,0 +1,260 @@
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'fs'
+import { dirname, isAbsolute, relative, resolve } from 'path'
+import { fileURLToPath } from 'url'
+import { homedir } from 'os'
+
+export const SKILL_NAME = 'orizu-cli'
+export const AGENTS_START_MARKER = '<!-- orizu-cli:start -->'
+export const AGENTS_END_MARKER = '<!-- orizu-cli:end -->'
+
+export const SKILL_INSTALL_TARGETS = [
+  'agent-user',
+  'codex-project',
+  'claude-user',
+  'claude-project',
+  'agents-md',
+] as const
+
+export type SkillInstallTarget = typeof SKILL_INSTALL_TARGETS[number]
+
+export interface SkillInstallOptions {
+  cwd?: string
+  homeDir?: string
+  overwrite?: boolean
+  dryRun?: boolean
+}
+
+export interface SkillInstallResult {
+  target: SkillInstallTarget
+  path: string
+  action: 'created' | 'updated' | 'would-create' | 'would-update'
+}
+
+function getCliRoot(): string {
+  return resolve(dirname(fileURLToPath(import.meta.url)), '..')
+}
+
+function isSkillDir(path: string): boolean {
+  return existsSync(resolve(path, 'SKILL.md'))
+}
+
+export function isSafeRelativeSkillPath(rel: string): boolean {
+  return rel !== '..' && !rel.startsWith('../') && !isAbsolute(rel)
+}
+
+export function formatMissingSkillSourceError(paths: string[]): string {
+  return `Unable to find bundled ${SKILL_NAME} skill. Reinstall the orizu CLI or run from the Orizu repository.\n`
+    + `Searched:\n- ${paths.join('\n- ')}`
+}
+
+export function resolveSkillSourceDir(): string {
+  const override = process.env.ORIZU_SKILL_SOURCE_DIR
+  if (override) {
+    const resolvedOverride = resolve(override)
+    if (!isSkillDir(resolvedOverride)) {
+      throw new Error(`ORIZU_SKILL_SOURCE_DIR is not an Orizu skill directory: ${resolvedOverride}`)
+    }
+    return resolvedOverride
+  }
+
+  const cliRoot = getCliRoot()
+  const packagedSkill = resolve(cliRoot, 'vendor', 'skills', SKILL_NAME)
+  if (isSkillDir(packagedSkill)) {
+    return packagedSkill
+  }
+
+  const repoSkill = resolve(cliRoot, '..', '..', 'skills', SKILL_NAME)
+  if (isSkillDir(repoSkill)) {
+    return repoSkill
+  }
+
+  const searchedPaths = [
+    `packaged skill: ${packagedSkill}`,
+    `repository fallback: ${repoSkill}`,
+  ]
+
+  throw new Error(formatMissingSkillSourceError(searchedPaths))
+}
+
+function resolveHome(options?: SkillInstallOptions): string {
+  return resolve(options?.homeDir || process.env.HOME || homedir())
+}
+
+function resolveCwd(options?: SkillInstallOptions): string {
+  return resolve(options?.cwd || process.cwd())
+}
+
+export function getSkillInstallPath(
+  target: SkillInstallTarget,
+  options?: SkillInstallOptions
+): string {
+  const home = resolveHome(options)
+  const cwd = resolveCwd(options)
+
+  if (target === 'agent-user') {
+    return resolve(home, '.agents', 'skills', SKILL_NAME)
+  }
+
+  if (target === 'codex-project') {
+    return resolve(cwd, '.codex', 'skills', SKILL_NAME)
+  }
+
+  if (target === 'claude-user') {
+    return resolve(home, '.claude', 'skills', SKILL_NAME)
+  }
+
+  if (target === 'claude-project') {
+    return resolve(cwd, '.claude', 'skills', SKILL_NAME)
+  }
+
+  return resolve(cwd, 'AGENTS.md')
+}
+
+function shouldCopySkillPath(sourceRoot: string, sourcePath: string): boolean {
+  const rel = relative(sourceRoot, sourcePath).replace(/\\/g, '/')
+  if (!rel) {
+    return true
+  }
+  if (!isSafeRelativeSkillPath(rel)) {
+    return false
+  }
+
+  const parts = rel.split('/')
+  return !parts.some(part =>
+    part === '.DS_Store' ||
+    part === '__pycache__' ||
+    part === '.pytest_cache'
+  ) && !rel.endsWith('.pyc') && !rel.endsWith('.pyo')
+}
+
+function copySkillTree(sourceDir: string, targetDir: string) {
+  rmSync(targetDir, { recursive: true, force: true })
+  mkdirSync(dirname(targetDir), { recursive: true })
+  cpSync(sourceDir, targetDir, {
+    recursive: true,
+    filter: sourcePath => shouldCopySkillPath(sourceDir, sourcePath),
+  })
+}
+
+function stripFrontmatter(markdown: string): string {
+  const match = markdown.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n/)
+  if (!match) {
+    return markdown
+  }
+
+  return markdown.slice(match[0].length).replace(/^[\r\n]+/, '')
+}
+
+function buildAgentsSection(sourceDir: string): string {
+  const skillMarkdown = readFileSync(resolve(sourceDir, 'SKILL.md'), 'utf8')
+  const body = stripFrontmatter(skillMarkdown).trimEnd()
+  return `${AGENTS_START_MARKER}\n${body}\n${AGENTS_END_MARKER}\n`
+}
+
+function installAgentsMd(
+  sourceDir: string,
+  targetPath: string,
+  options?: SkillInstallOptions
+): SkillInstallResult {
+  const section = buildAgentsSection(sourceDir)
+  const exists = existsSync(targetPath)
+  const existing = exists ? readFileSync(targetPath, 'utf8') : ''
+  const hasManagedSection = existing.includes(AGENTS_START_MARKER)
+    && existing.includes(AGENTS_END_MARKER)
+  const action = exists ? 'updated' : 'created'
+
+  if (options?.dryRun) {
+    return {
+      target: 'agents-md',
+      path: targetPath,
+      action: action === 'updated' ? 'would-update' : 'would-create',
+    }
+  }
+
+  if (hasManagedSection && !options?.overwrite) {
+    throw new Error(`${targetPath} already contains an Orizu CLI section. Pass --yes to replace it.`)
+  }
+
+  mkdirSync(dirname(targetPath), { recursive: true })
+  if (!exists) {
+    writeFileSync(targetPath, section, 'utf8')
+    return { target: 'agents-md', path: targetPath, action: 'created' }
+  }
+
+  if (hasManagedSection) {
+    const pattern = new RegExp(
+      `${escapeRegExp(AGENTS_START_MARKER)}[\\s\\S]*?${escapeRegExp(AGENTS_END_MARKER)}\\n?`
+    )
+    writeFileSync(targetPath, existing.replace(pattern, section), 'utf8')
+    return { target: 'agents-md', path: targetPath, action: 'updated' }
+  }
+
+  const existingPrefix = existing.trim().length === 0 ? '' : existing
+  const separator = existingPrefix.endsWith('\n') ? '\n' : '\n\n'
+  writeFileSync(targetPath, `${existingPrefix}${existingPrefix ? separator : ''}${section}`, 'utf8')
+  return { target: 'agents-md', path: targetPath, action: 'updated' }
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+export function targetNeedsOverwrite(
+  target: SkillInstallTarget,
+  options?: SkillInstallOptions
+): boolean {
+  const targetPath = getSkillInstallPath(target, options)
+  if (!existsSync(targetPath)) {
+    return false
+  }
+
+  if (target !== 'agents-md') {
+    return true
+  }
+
+  const existing = readFileSync(targetPath, 'utf8')
+  return existing.includes(AGENTS_START_MARKER) && existing.includes(AGENTS_END_MARKER)
+}
+
+export function installSkillTarget(
+  target: SkillInstallTarget,
+  options?: SkillInstallOptions
+): SkillInstallResult {
+  const sourceDir = resolveSkillSourceDir()
+  const targetPath = getSkillInstallPath(target, options)
+  const exists = existsSync(targetPath)
+
+  if (target === 'agents-md') {
+    return installAgentsMd(sourceDir, targetPath, options)
+  }
+
+  if (options?.dryRun) {
+    return {
+      target,
+      path: targetPath,
+      action: exists ? 'would-update' : 'would-create',
+    }
+  }
+
+  if (exists && !options?.overwrite) {
+    throw new Error(`${targetPath} already exists. Pass --yes to replace it.`)
+  }
+
+  copySkillTree(sourceDir, targetPath)
+  return {
+    target,
+    path: targetPath,
+    action: exists ? 'updated' : 'created',
+  }
+}
+
+export function isSkillInstallTarget(value: string): value is SkillInstallTarget {
+  return (SKILL_INSTALL_TARGETS as readonly string[]).includes(value)
+}

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

@@ -1,19 +1,23 @@
 from .optimizer import (
     Budget,
     DatasetRow,
+    NumThreadsPlan,
     PromptContext,
     RowEvaluation,
     TextGepaConfig,
     TextGepaResult,
     optimize_text_candidate,
+    resolve_num_threads,
 )
 
 __all__ = [
     "Budget",
     "DatasetRow",
+    "NumThreadsPlan",
     "PromptContext",
     "RowEvaluation",
     "TextGepaConfig",
     "TextGepaResult",
     "optimize_text_candidate",
+    "resolve_num_threads",
 ]

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

@@ -19,6 +19,12 @@ def positive_int(value: str) -> int:
     return parsed
 
 
+def num_threads_arg(value: str) -> int | str:
+    if value.strip().lower() == "auto":
+        return "auto"
+    return positive_int(value)
+
+
 def read_text_arg(value: str | None) -> str | None:
     if value is None:
         return None
@@ -54,9 +60,10 @@ 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", "high"])
+    parser.add_argument("--budget", default="light", choices=["auto", "light", "medium", "heavy"])
     parser.add_argument("--max-iterations", type=positive_int, default=3)
     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(
         "--candidate-selection-strategy",
         default=TextGepaConfig.candidate_selection_strategy,
@@ -71,6 +78,19 @@ def main() -> None:
     parser.add_argument("--reflection-max-tokens", type=positive_int)
     parser.add_argument("--reflection-prompt-template")
     parser.add_argument("--reflection-provider-settings")
+    parser.add_argument(
+        "--skip-perfect-parent-reflection",
+        dest="skip_perfect_parent_reflection",
+        action="store_true",
+        default=TextGepaConfig.skip_perfect_parent_reflection,
+        help="Skip reflection and child creation when the parent scores perfectly on the minibatch (default).",
+    )
+    parser.add_argument(
+        "--no-skip-perfect-parent-reflection",
+        dest="skip_perfect_parent_reflection",
+        action="store_false",
+        help="Reflect and create a child even when the parent scores perfectly on the minibatch.",
+    )
     parser.add_argument("--objective", default=TextGepaConfig.objective)
     parser.add_argument("--seed", type=int, default=0)
     parser.add_argument("--auto-promote", action="store_true")
@@ -89,6 +109,7 @@ def main() -> None:
         budget=args.budget,
         max_iterations=args.max_iterations,
         minibatch_size=args.minibatch_size,
+        num_threads=args.num_threads,
         candidate_selection_strategy=args.candidate_selection_strategy,
         epsilon=args.epsilon,
         max_metric_calls=args.max_metric_calls,
@@ -98,6 +119,7 @@ def main() -> None:
         reflection_max_tokens=args.reflection_max_tokens,
         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,
         objective=args.objective,
         seed=args.seed,
         auto_promote=args.auto_promote,
@@ -139,6 +161,7 @@ def main() -> None:
         "dataset_size": len(trainset) + len(valset),
         "train_count": len(trainset),
         "validation_count": len(valset),
+        "num_threads": args.num_threads,
     }
 
     run_id = client.start_run(