codex-flow 2.1.13__py3-none-any.whl

codex_flow/data/completions/codex-flow.zsh

@@ -0,0 +1,52 @@
+#compdef codex-flow
+
+_codex_flow() {
+    local -a commands
+    commands=(
+        'status:Show installed version and effective FlowPilot strategy'
+        'strategy:Inspect or configure the multi-strategy runtime'
+        'language:Show or set UI language (auto/zh/en)'
+        'update:Pull the checkout and refresh recommendations'
+        'doctor:Verify installation, strategy runtime, and telemetry'
+        'overlay:Manage the native macOS floating widget'
+        'usage:Show deterministic FlowPilot usage summaries and history'
+        'telemetry:Telemetry collection, inspection, and historical repair'
+        'benchmark-local:Run the built-in benchmark through the local Codex login'
+        'benchmark-corpus:Materialize the built-in corpus'
+        'benchmark:Run a reproducible benchmark manifest'
+        'benchmark-analyze:Analyze benchmark JSONL results'
+        'uninstall:Remove codex-flow-managed files'
+        'help:Show command help'
+    )
+    if (( CURRENT == 2 )); then
+        _describe 'command' commands
+    elif (( CURRENT == 3 )) && [[ "${words[2]}" == strategy ]]; then
+        _describe 'strategy command' '(show profiles enabled enable disable set routing plan)'
+    elif (( CURRENT == 4 )) && [[ "${words[2]}" == strategy && "${words[3]}" == set ]]; then
+        _describe 'strategy profile' '(efficient balanced quality speed)'
+    elif (( CURRENT == 4 )) && [[ "${words[2]}" == strategy && "${words[3]}" == routing ]]; then
+        _describe 'routing mode' '(adaptive direct delegate)'
+    elif (( CURRENT >= 4 )) && [[ "${words[2]}" == strategy && "${words[3]}" == plan ]]; then
+        _describe 'plan option' '(--profile --routing --review --fanout --complexity --uncertainty --risk --scope --parallelism --write-conflict --exploration-need --verification-cost --iteration-intensity --writable-workstreams --quality-intent --quota-pressure --max-threads --max-repairs)'
+    elif (( CURRENT == 3 )) && [[ "${words[2]}" == language ]]; then
+        _describe 'language' '(auto zh en)'
+    elif (( CURRENT == 3 )) && [[ "${words[2]}" == benchmark-local || "${words[2]}" == benchmark-corpus ]]; then
+        _describe 'profile' '(quick full)'
+    elif (( CURRENT == 3 )) && [[ "${words[2]}" == usage || "${words[2]}" == telemetry ]]; then
+        _describe 'usage command' '(last list show stats summary repair)'
+    elif (( CURRENT >= 4 )) && [[ "${words[2]}" == usage || "${words[2]}" == telemetry ]]; then
+        case "${words[3]}" in
+            last|show) _describe 'usage option' '(--json)' ;;
+            list) _describe 'list option' '(--json --today -n --limit -p --project)' ;;
+            stats|summary) _describe 'stats option' '(--json -d --days -p --project)' ;;
+            repair) _describe 'repair option' '(--dry-run --json)' ;;
+        esac
+    fi
+}
+if (( $+functions[compdef] )); then
+    compdef _codex_flow codex-flow
+else
+    autoload -Uz compinit
+    compinit -i >/dev/null 2>&1 || true
+    (( $+functions[compdef] )) && compdef _codex_flow codex-flow
+fi

codex_flow/data/glama.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://glama.ai/mcp/schemas/server.json",
+  "maintainers": [
+    "Parsifal"
+  ]
+}

codex_flow/data/install-release.ps1

@@ -0,0 +1,126 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 2.0
+
+$Repo = if ($env:CODEX_FLOW_REPO) { $env:CODEX_FLOW_REPO } else { 'ParsifalC/codex-flow' }
+$Channel = if ($env:CODEX_FLOW_UPDATE_CHANNEL) { $env:CODEX_FLOW_UPDATE_CHANNEL } else { 'stable' }
+$CodexHome = if ($env:CODEX_HOME) { $env:CODEX_HOME } else { Join-Path $HOME '.codex' }
+$StateDir = Join-Path $CodexHome 'codex-flow'
+$VersionsDir = Join-Path $StateDir 'versions'
+$TempRoot = Join-Path ([System.IO.Path]::GetTempPath()) ('codex-flow-install-' + [Guid]::NewGuid().ToString('N'))
+
+function Fail([string]$Message) { throw "codex-flow installer: $Message" }
+function Say([string]$Message) { Write-Host $Message }
+
+if ($Channel -ne 'stable') {
+    Fail "first-install bootstrap currently supports the stable channel only; install stable first, then switch update.channel to $Channel"
+}
+
+# Windows PowerShell 5 can otherwise negotiate an obsolete TLS version on older systems.
+try {
+    [Net.ServicePointManager]::SecurityProtocol = [Net.ServicePointManager]::SecurityProtocol -bor [Net.SecurityProtocolType]::Tls12
+} catch {}
+
+$archName = if ($env:PROCESSOR_ARCHITEW6432) { $env:PROCESSOR_ARCHITEW6432 } else { $env:PROCESSOR_ARCHITECTURE }
+switch -Regex ($archName) {
+    '^(ARM64|arm64)$' { $Arch = 'arm64'; break }
+    '^(AMD64|x86_64|amd64)$' { $Arch = 'x86_64'; break }
+    default { Fail "unsupported CPU architecture: $archName" }
+}
+$Platform = "windows-$Arch"
+
+New-Item -ItemType Directory -Force -Path $TempRoot,$VersionsDir | Out-Null
+try {
+    $ManifestPath = Join-Path $TempRoot 'codex-flow-update.json'
+    $ManifestUrl = "https://github.com/$Repo/releases/latest/download/codex-flow-update.json"
+    Say "-> Resolving latest codex-flow release for $Platform"
+    try {
+        Invoke-WebRequest -UseBasicParsing -Uri $ManifestUrl -OutFile $ManifestPath
+    } catch {
+        Fail 'no OTA-enabled stable release is available yet; publish a stable release containing codex-flow-update.json before using the release bootstrap'
+    }
+
+    $Manifest = Get-Content -Raw -Encoding UTF8 $ManifestPath | ConvertFrom-Json
+    if ($Manifest.channel -ne 'stable') { Fail 'latest release manifest is not stable' }
+    $Artifacts = $Manifest.artifacts
+    if (-not $Artifacts) { Fail 'release manifest does not contain artifacts' }
+    $ArtifactProperty = $Artifacts.PSObject.Properties[$Platform]
+    $Artifact = if ($ArtifactProperty) { $ArtifactProperty.Value } else { $null }
+    if (-not $Artifact) { Fail "release does not contain artifact for $Platform" }
+    if (-not $Artifact.url -or -not $Artifact.sha256 -or -not $Artifact.format) { Fail 'release manifest contains an incomplete artifact entry' }
+    if ($Artifact.format -ne 'zip') { Fail "unsupported Windows release archive format: $($Artifact.format)" }
+
+    $Version = [string]$Manifest.version
+    if (-not $Version) { Fail 'release manifest does not contain a version' }
+    $Archive = Join-Path $TempRoot 'codex-flow.zip'
+    Say "-> Downloading codex-flow v$Version"
+    Invoke-WebRequest -UseBasicParsing -Uri ([string]$Artifact.url) -OutFile $Archive
+
+    $ActualSha = (Get-FileHash -Algorithm SHA256 -Path $Archive).Hash.ToLowerInvariant()
+    $ExpectedSha = ([string]$Artifact.sha256).Trim().ToLowerInvariant()
+    if ($ActualSha -ne $ExpectedSha) { Fail 'SHA-256 mismatch for downloaded release' }
+    Say 'OK SHA-256 verified'
+
+    Add-Type -AssemblyName System.IO.Compression.FileSystem
+    $ExtractDir = Join-Path $TempRoot 'package'
+    New-Item -ItemType Directory -Force -Path $ExtractDir | Out-Null
+    $ExtractRoot = [System.IO.Path]::GetFullPath($ExtractDir + [System.IO.Path]::DirectorySeparatorChar)
+    $Zip = [System.IO.Compression.ZipFile]::OpenRead($Archive)
+    try {
+        foreach ($Entry in $Zip.Entries) {
+            $Target = [System.IO.Path]::GetFullPath((Join-Path $ExtractDir $Entry.FullName))
+            if (-not $Target.StartsWith($ExtractRoot, [System.StringComparison]::OrdinalIgnoreCase)) {
+                Fail "unsafe archive member: $($Entry.FullName)"
+            }
+        }
+    } finally {
+        $Zip.Dispose()
+    }
+    [System.IO.Compression.ZipFile]::ExtractToDirectory($Archive, $ExtractDir)
+
+    $PackageRoot = Join-Path $ExtractDir "codex-flow-$Version"
+    $Installer = Join-Path $PackageRoot 'install.ps1'
+    if (-not (Test-Path -LiteralPath $Installer -PathType Leaf)) { Fail 'release package does not contain install.ps1 at the expected root' }
+
+    $VersionDir = Join-Path $VersionsDir $Version
+    $StageDir = Join-Path $VersionsDir ('.install-' + $Version + '-' + [Guid]::NewGuid().ToString('N'))
+    Move-Item -LiteralPath $PackageRoot -Destination $StageDir
+
+    if (Test-Path -LiteralPath $VersionDir) {
+        $ExistingSource = Join-Path $StateDir 'source'
+        $CurrentSource = if (Test-Path $ExistingSource) { (Get-Content -Raw -Encoding UTF8 $ExistingSource).Trim() } else { '' }
+        if ($CurrentSource -and ([System.IO.Path]::GetFullPath($CurrentSource) -eq [System.IO.Path]::GetFullPath($VersionDir))) {
+            $BackupDir = Join-Path $VersionsDir ('.previous-install-' + $Version + '-' + [Guid]::NewGuid().ToString('N'))
+            Move-Item -LiteralPath $VersionDir -Destination $BackupDir
+            try {
+                Move-Item -LiteralPath $StageDir -Destination $VersionDir
+                Remove-Item -LiteralPath $BackupDir -Recurse -Force -ErrorAction SilentlyContinue
+            } catch {
+                if (-not (Test-Path $VersionDir) -and (Test-Path $BackupDir)) { Move-Item -LiteralPath $BackupDir -Destination $VersionDir }
+                throw
+            }
+        } else {
+            Remove-Item -LiteralPath $VersionDir -Recurse -Force
+            Move-Item -LiteralPath $StageDir -Destination $VersionDir
+        }
+    } else {
+        Move-Item -LiteralPath $StageDir -Destination $VersionDir
+    }
+
+    $PersistentInstaller = Join-Path $VersionDir 'install.ps1'
+    Say "-> Installing codex-flow v$Version"
+    & powershell.exe -NoProfile -ExecutionPolicy Bypass -File $PersistentInstaller
+    if ($LASTEXITCODE -ne 0) { Fail "install.ps1 exited with code $LASTEXITCODE" }
+
+    $Doctor = Join-Path $StateDir 'doctor.py'
+    if (Test-Path $Doctor) {
+        Say '-> Running doctor'
+        & python3 $Doctor
+        if ($LASTEXITCODE -ne 0) { Fail "doctor exited with code $LASTEXITCODE" }
+    }
+
+    Say ''
+    Say "OK codex-flow v$Version installation complete"
+    Say '   Fully restart Codex to activate the new Agent / Skill / Hook / policy snapshot.'
+} finally {
+    Remove-Item -LiteralPath $TempRoot -Recurse -Force -ErrorAction SilentlyContinue
+}

codex_flow/data/install-release.sh

@@ -0,0 +1,155 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO="${CODEX_FLOW_REPO:-ParsifalC/codex-flow}"
+CHANNEL="${CODEX_FLOW_UPDATE_CHANNEL:-stable}"
+CODEX_HOME="${CODEX_HOME:-$HOME/.codex}"
+STATE_DIR="$CODEX_HOME/codex-flow"
+TMP_DIR="$(mktemp -d "${TMPDIR:-/tmp}/codex-flow-install.XXXXXX")"
+trap 'rm -rf "$TMP_DIR"' EXIT
+
+say() { printf '%s\n' "$*"; }
+fail() { printf 'codex-flow installer: %s\n' "$*" >&2; exit 1; }
+
+command -v curl >/dev/null 2>&1 || fail "curl is required"
+command -v python3 >/dev/null 2>&1 || fail "python3 is required"
+
+case "$(uname -s)" in
+  Darwin) os="darwin" ;;
+  Linux) os="linux" ;;
+  *) fail "unsupported operating system: $(uname -s)" ;;
+esac
+
+case "$(uname -m)" in
+  arm64|aarch64) arch="arm64" ;;
+  x86_64|amd64) arch="x86_64" ;;
+  *) fail "unsupported CPU architecture: $(uname -m)" ;;
+esac
+
+platform="$os-$arch"
+
+if [[ "$CHANNEL" != "stable" ]]; then
+  fail "first-install bootstrap currently supports the stable channel only; install stable first, then switch update.channel to $CHANNEL"
+fi
+
+manifest_url="https://github.com/$REPO/releases/latest/download/codex-flow-update.json"
+manifest="$TMP_DIR/codex-flow-update.json"
+say "→ Resolving latest codex-flow release for $platform"
+if ! curl -fL --retry 3 --connect-timeout 15 "$manifest_url" -o "$manifest"; then
+  fail "no OTA-enabled stable release is available yet; publish a stable release containing codex-flow-update.json before using the release bootstrap"
+fi
+
+IFS=$'\t' read -r version artifact_url expected_sha archive_format < <(python3 - "$manifest" "$platform" <<'PY'
+import json, sys
+from pathlib import Path
+manifest_path, platform = Path(sys.argv[1]), sys.argv[2]
+data = json.loads(manifest_path.read_text(encoding="utf-8"))
+if data.get("channel") != "stable":
+    raise SystemExit("latest release manifest is not stable")
+artifact = (data.get("artifacts") or {}).get(platform)
+if not artifact:
+    raise SystemExit(f"release does not contain artifact for {platform}")
+for key in ("url", "sha256", "format"):
+    if not artifact.get(key):
+        raise SystemExit(f"artifact is missing {key}")
+print("\t".join((
+    data.get("version") or "unknown",
+    artifact["url"],
+    artifact["sha256"].lower(),
+    artifact["format"],
+)))
+PY
+)
+
+[[ -n "${version:-}" && -n "${artifact_url:-}" && -n "${expected_sha:-}" && -n "${archive_format:-}" ]] || fail "invalid release manifest"
+
+case "$archive_format" in
+  tar.gz) archive="$TMP_DIR/codex-flow.tar.gz" ;;
+  zip) archive="$TMP_DIR/codex-flow.zip" ;;
+  *) fail "unsupported release archive format: $archive_format" ;;
+esac
+
+say "→ Downloading codex-flow v$version"
+curl -fL --retry 3 --connect-timeout 15 "$artifact_url" -o "$archive"
+
+actual_sha="$(python3 - "$archive" <<'PY'
+import hashlib, sys
+h = hashlib.sha256()
+with open(sys.argv[1], "rb") as f:
+    for chunk in iter(lambda: f.read(1024 * 1024), b""):
+        h.update(chunk)
+print(h.hexdigest())
+PY
+)"
+[[ "$actual_sha" == "$expected_sha" ]] || fail "SHA-256 mismatch for downloaded release"
+say "✓ SHA-256 verified"
+
+package_dir="$TMP_DIR/package"
+mkdir -p "$package_dir"
+case "$archive_format" in
+  tar.gz)
+    command -v tar >/dev/null 2>&1 || fail "tar is required"
+    tar -xzf "$archive" -C "$package_dir"
+    ;;
+  zip)
+    command -v unzip >/dev/null 2>&1 || fail "unzip is required"
+    unzip -q "$archive" -d "$package_dir"
+    ;;
+esac
+
+install_script="$(find "$package_dir" -type f -name install.sh -print | head -n 1)"
+[[ -n "$install_script" ]] || fail "release package does not contain install.sh"
+extracted_root="$(cd "$(dirname "$install_script")" && pwd)"
+
+versions_dir="$STATE_DIR/versions"
+version_dir="$versions_dir/$version"
+staged_version_dir="$versions_dir/.${version}.installing.$$"
+mkdir -p "$versions_dir"
+rm -rf "$staged_version_dir"
+mkdir -p "$staged_version_dir"
+cp -R "$extracted_root"/. "$staged_version_dir"/
+[[ -f "$staged_version_dir/install.sh" ]] || fail "staged release package is incomplete"
+rm -rf "$version_dir"
+mv "$staged_version_dir" "$version_dir"
+
+say "→ Installing codex-flow v$version"
+(
+  cd "$version_dir"
+  bash ./install.sh
+)
+
+if [[ "$os" == "darwin" ]]; then
+  flowpilot="$STATE_DIR/bin/FlowPilot"
+  legacy_overlay="$STATE_DIR/bin/codex-flow-overlay"
+  if [[ -s "$flowpilot" && -x "$flowpilot" ]]; then
+    overlay_bin="$flowpilot"
+  elif [[ -s "$legacy_overlay" && -x "$legacy_overlay" ]]; then
+    overlay_bin="$legacy_overlay"
+  else
+    fail "macOS release installed successfully, but no prebuilt FlowPilot binary was found"
+  fi
+
+  say "→ Starting FlowPilot"
+  "$overlay_bin" stop >/dev/null 2>&1 || true
+  pkill -f "FlowPilot.*start|codex-flow-overlay.*start|bin/FlowPilot" 2>/dev/null || true
+  sleep 0.2
+  nohup "$overlay_bin" start >/dev/null 2>&1 &
+  disown $! 2>/dev/null || true
+  sleep 0.4
+
+  if pgrep -f "FlowPilot.*start|codex-flow-overlay.*start|bin/FlowPilot" >/dev/null 2>&1; then
+    say "✓ FlowPilot is running in the background"
+  else
+    say "! codex-flow installed, but FlowPilot did not stay running. Retry with: codex-flow overlay start" >&2
+  fi
+fi
+
+doctor="$STATE_DIR/doctor.py"
+if [[ -f "$doctor" ]]; then
+  say "→ Running doctor"
+  python3 "$doctor"
+fi
+
+say ""
+say "✓ codex-flow v$version installation complete"
+say "  Fully restart Codex to activate the new Agent / Skill / Hook / policy snapshot."