@surlymochan/evalid 0.0.0-stage → 0.4.1

package/xflow/atoms/a1_issue_create_or_patch.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+A1.issue.create_or_patch — GitHub issue create or patch.
+Delegates to open_issue_flow.py. Accepts same CLI args.
+"""
+import sys, os, json, subprocess
+from pathlib import Path
+
+def cli_value(flag):
+    argv = sys.argv[1:]
+    for index, arg in enumerate(argv):
+        if arg == flag and index + 1 < len(argv):
+            return argv[index + 1]
+    return None
+
+def load_body_from_cli():
+    body_file = cli_value("--body-file")
+    if body_file:
+        return Path(body_file).expanduser().read_text(encoding="utf-8")
+    return cli_value("--body")
+
+def ensure_issue_doc(project_root, change_id):
+    body = load_body_from_cli()
+    if not body:
+        return False
+    change_root = Path(project_root).expanduser().resolve() / "specs" / "changes" / change_id
+    change_root.mkdir(parents=True, exist_ok=True)
+    title = cli_value("--title") or change_id
+    issue_path = change_root / "issue.md"
+    issue_path.write_text(f"# {title}\n\n{body.strip()}\n", encoding="utf-8")
+    return True
+
+def main():
+    project_root = "."
+    change_id = None
+    for index, arg in enumerate(sys.argv[1:]):
+        if arg == "--project-root" and index + 2 <= len(sys.argv[1:]):
+            project_root = sys.argv[index + 2]
+        elif arg == "--change-id" and index + 2 <= len(sys.argv[1:]):
+            change_id = sys.argv[index + 2]
+
+    if change_id:
+        status_path = Path(project_root).expanduser().resolve() / "specs" / "changes" / change_id / "status.json"
+        issue_path = status_path.parent / "issue.md"
+        if status_path.exists():
+            try:
+                status = json.loads(status_path.read_text())
+                if status.get("issue_number") and status.get("branch_name") and status.get("checkout_path"):
+                    if not issue_path.exists():
+                        ensure_issue_doc(project_root, change_id)
+                    if not issue_path.exists():
+                        raise RuntimeError("issue.md is still missing for prepared issue")
+                    print(json.dumps({
+                        "ok": True,
+                        "skipped": True,
+                        "reason": "issue_already_prepared",
+                        "issue_number": status.get("issue_number"),
+                        "branch_name": status.get("branch_name"),
+                        "checkout_path": status.get("checkout_path"),
+                    }))
+                    return
+            except Exception:
+                pass
+
+    script = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'openissue', 'scripts', 'open_issue_flow.py'))
+    result = subprocess.run([sys.executable, script] + sys.argv[1:])
+    sys.exit(result.returncode)
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/a2_branch_create_and_link.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""
+A2.branch.create_and_link — Create branch and link to issue.
+Delegates to open_issue_flow.py with --branch-only flag (if supported)
+or as part of the full issue flow.
+"""
+import sys, os, json, subprocess
+from pathlib import Path
+
+def main():
+    project_root = "."
+    change_id = None
+    for index, arg in enumerate(sys.argv[1:]):
+        if arg == "--project-root" and index + 2 <= len(sys.argv[1:]):
+            project_root = sys.argv[index + 2]
+        elif arg == "--change-id" and index + 2 <= len(sys.argv[1:]):
+            change_id = sys.argv[index + 2]
+
+    if change_id:
+        status_path = Path(project_root).expanduser().resolve() / "specs" / "changes" / change_id / "status.json"
+        if status_path.exists():
+            try:
+                status = json.loads(status_path.read_text())
+                if status.get("issue_number") and status.get("branch_name") and status.get("checkout_path"):
+                    print(json.dumps({
+                        "ok": True,
+                        "skipped": True,
+                        "reason": "branch_already_prepared",
+                        "issue_number": status.get("issue_number"),
+                        "branch_name": status.get("branch_name"),
+                        "checkout_path": status.get("checkout_path"),
+                    }))
+                    return
+            except Exception:
+                pass
+
+    script = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'openissue', 'scripts', 'open_issue_flow.py'))
+    result = subprocess.run([sys.executable, script] + sys.argv[1:])
+    sys.exit(result.returncode)
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/a3_repo_doctor.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""A3.repo.doctor — Consistency check. Delegates to doctor.py."""
+import sys, os, subprocess
+
+def main():
+    script = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'scripts', 'doctor.py'))
+    result = subprocess.run([sys.executable, script] + sys.argv[1:])
+    sys.exit(result.returncode)
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/a4_project_set_status.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""A4.project.set_status — Move GitHub project item to target status. Delegates to set_issue_in_progress.py."""
+import sys, os, subprocess
+
+def main():
+    script = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'exec', 'scripts', 'set_issue_in_progress.py'))
+    result = subprocess.run([sys.executable, script] + sys.argv[1:])
+    sys.exit(result.returncode)
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/a5_archive_commit_push_close.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""A5.archive.commit_push_close — Commit, push branch, close issue, mark project Done. Delegates to archive_change.py."""
+import sys, os, subprocess
+
+def main():
+    script = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'archive', 'scripts', 'archive_change.py'))
+    result = subprocess.run([sys.executable, script] + sys.argv[1:])
+    sys.exit(result.returncode)
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/a6_pr_create.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""
+A6.pr.create — Open a PR from issue branch against base.
+Uses gh pr create. Reads change context from status.json.
+"""
+import sys, os, json, argparse, subprocess
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'scripts'))
+from common import load_status
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--project-root', default='.')
+    p.add_argument('--change-id', required=True)
+    p.add_argument('--base-branch', default='main')
+    p.add_argument('--draft', action='store_true')
+    args = p.parse_args()
+
+    _, status = load_status(args.project_root, args.change_id)
+    repo = status.get('code_repo', '')
+    branch = status.get('branch_name', '')
+    issue_num = status.get('issue_number')
+    issue_repo = status.get('issue_repo') or status.get('target_repo') or repo
+    issue_url = status.get('issue_url')
+    title = status.get('title', args.change_id)
+    checkout_path = status.get('checkout_path') or args.project_root
+
+    if not repo or not branch:
+        print(json.dumps({'ok': False, 'error': 'Missing code_repo or branch_name in status.json'}))
+        sys.exit(1)
+
+    if issue_url:
+        body = f'Tracks {issue_url}'
+    elif issue_num and issue_repo and issue_repo != repo:
+        body = f'Tracks {issue_repo}#{issue_num}'
+    else:
+        body = f'Closes #{issue_num}' if issue_num else ''
+    cmd = ['gh', 'pr', 'create',
+           '--repo', repo,
+           '--head', branch,
+           '--base', args.base_branch,
+           '--title', title,
+           '--body', body]
+    if args.draft:
+        cmd.append('--draft')
+
+    result = subprocess.run(cmd, cwd=checkout_path, capture_output=True, text=True)
+    if result.returncode != 0:
+        # PR may already exist
+        stderr = result.stderr or ''
+        if 'already exists' in stderr:
+            view = subprocess.run(
+                ['gh', 'pr', 'view', '--repo', repo, '--json', 'url', '--head', branch],
+                cwd=checkout_path,
+                capture_output=True,
+                text=True,
+            )
+            pr_url = None
+            if view.returncode == 0 and view.stdout.strip():
+                try:
+                    pr_url = json.loads(view.stdout).get('url')
+                except Exception:
+                    pr_url = None
+            print(json.dumps({'ok': True, 'message': 'PR already exists', 'pr_url': pr_url}))
+            sys.exit(0)
+        print(json.dumps({'ok': False, 'error': stderr}))
+        sys.exit(1)
+
+    pr_url = result.stdout.strip()
+    print(json.dumps({'ok': True, 'pr_url': pr_url}))
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/b1_change_scaffold.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""B1.change.scaffold — Initialize specs/changes/<change_id>/. Delegates to scaffold_specs_change.py."""
+import sys, os, subprocess
+
+def main():
+    script = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'yolo', 'scripts', 'scaffold_specs_change.py'))
+    result = subprocess.run([sys.executable, script] + sys.argv[1:])
+    sys.exit(result.returncode)
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/b2_status_read.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+"""B2.status.read — Read and return status.json for a change."""
+import sys, os, json, argparse
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'scripts'))
+from common import load_status
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--project-root', default='.')
+    p.add_argument('--change-id', required=True)
+    args = p.parse_args()
+    status = load_status(args.project_root, args.change_id)
+    print(json.dumps(status, indent=2))
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/b2b_status_write.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+"""B2b.status.write — Merge fields into status.json."""
+import sys, os, json, argparse
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'scripts'))
+from common import load_status, save_status
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--project-root', default='.')
+    p.add_argument('--change-id', required=True)
+    p.add_argument('--fields', required=True, help='JSON object of fields to merge')
+    args = p.parse_args()
+    fields = json.loads(args.fields)
+    path, status = load_status(args.project_root, args.change_id)
+    status.update(fields)
+    save_status(path, status)
+    print(json.dumps({'ok': True, 'updated': list(fields.keys())}))
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/b3_status_transition.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""B3.status.transition — Assert and record a stage/status transition."""
+import sys, os, json, argparse
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'scripts'))
+from common import load_status, save_status, record_stage_transition
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--project-root', default='.')
+    p.add_argument('--change-id', required=True)
+    p.add_argument('--to-stage')
+    p.add_argument('--to-status')
+    p.add_argument('--reason', default='workflow-advance')
+    args = p.parse_args()
+
+    path, status = load_status(args.project_root, args.change_id)
+
+    if args.to_stage:
+        record_stage_transition(status, args.to_stage, reason=args.reason)
+    if args.to_status:
+        status['status'] = args.to_status
+
+    save_status(path, status)
+    print(json.dumps({'ok': True, 'stage': status.get('current_stage'), 'status': status.get('status')}))
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/b4_handoff_scaffold_or_refresh.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""B4.handoff.scaffold_or_refresh — Create/refresh HANDOFF.md. Delegates to scaffold_handoff.py."""
+import sys, os, subprocess
+
+def main():
+    script = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'handoff', 'scripts', 'scaffold_handoff.py'))
+    result = subprocess.run([sys.executable, script] + sys.argv[1:])
+    sys.exit(result.returncode)
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/b5_aha_append.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""B5.aha.append — Append AHA entry. Delegates to append_aha.py."""
+import sys, os, subprocess
+
+def main():
+    script = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'aha', 'scripts', 'append_aha.py'))
+    result = subprocess.run([sys.executable, script] + sys.argv[1:])
+    sys.exit(result.returncode)
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/b6_takein_digest.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""B6.takein.digest — Session rehydration digest. Delegates to takein_digest.py."""
+import sys, os, subprocess
+
+def main():
+    script = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'takein', 'scripts', 'takein_digest.py'))
+    result = subprocess.run([sys.executable, script] + sys.argv[1:])
+    sys.exit(result.returncode)
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/b6b_lookback_digest.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""B6b.lookback.digest — Lookback sources list. Delegates to lookback_digest.py."""
+import sys, os, subprocess
+
+def main():
+    script = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'lookback', 'scripts', 'lookback_digest.py'))
+    result = subprocess.run([sys.executable, script] + sys.argv[1:])
+    sys.exit(result.returncode)
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/b7_change_mission_bind.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""
+B7.change_mission.bind — The ONLY place that writes the change_id <-> mission_id coupling.
+Writes to .as-xflow/bindings.json (append-only, keyed by change_id).
+Does NOT touch state.sqlite or status.json schemas.
+"""
+import sys, os, json, argparse
+from datetime import datetime, timezone
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--project-root', default='.')
+    p.add_argument('--change-id', required=True)
+    p.add_argument('--mission-id', default=None)
+    p.add_argument('--direction', default='change_to_mission')
+    args = p.parse_args()
+
+    bindings_dir = os.path.join(args.project_root, '.as-xflow')
+    os.makedirs(bindings_dir, exist_ok=True)
+    bindings_file = os.path.join(bindings_dir, 'bindings.json')
+
+    bindings = {}
+    if os.path.exists(bindings_file):
+        try:
+            bindings = json.loads(open(bindings_file).read())
+        except Exception:
+            bindings = {}
+
+    entry = {
+        'change_id': args.change_id,
+        'mission_id': args.mission_id,
+        'direction': args.direction,
+        'bound_at': datetime.now(timezone.utc).isoformat(),
+    }
+    bindings[args.change_id] = entry
+
+    with open(bindings_file, 'w') as f:
+        json.dump(bindings, f, indent=2)
+
+    print(json.dumps({'ok': True, 'binding': entry}))
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/c1_mem.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""
+C1.mem — Opaque personal/global memory atom.
+Passes all arguments through to mem.sh verbatim.
+cli-use-memory directory structure is NOT modified by this atom.
+"""
+import json
+import os
+import subprocess
+import sys
+
+
+def candidate_mem_scripts():
+    env_script = os.environ.get('XMEM_MEM_SH')
+    if env_script:
+        yield env_script
+
+    here = os.path.dirname(__file__)
+    yield os.path.abspath(os.path.join(here, '..', '..', '..', 'as-xmem', 'mem.sh'))
+
+    home = os.path.expanduser('~')
+    for target in (
+        '.agents/skills/xmem/mem.sh',
+        '.codex/skills/xmem/mem.sh',
+        '.claude/skills/xmem/mem.sh',
+        '.hermes/skills/xmem/mem.sh',
+        '.openclaw/skills/xmem/mem.sh',
+        '.config/opencode/skills/xmem/mem.sh',
+    ):
+        yield os.path.join(home, target)
+
+
+def find_mem_script():
+    for script in candidate_mem_scripts():
+        if script and os.path.isfile(script):
+            return script
+    return None
+
+def main():
+    script = find_mem_script()
+    if not script:
+        print(json.dumps({
+            'ok': True,
+            'atom': 'C1.mem',
+            'skipped': True,
+            'reason': 'xmem mem.sh not found; install xmem to enable shared-memory persistence',
+        }))
+        return 0
+
+    result = subprocess.run(['bash', script] + sys.argv[1:])
+    return result.returncode
+
+if __name__ == '__main__':
+    sys.exit(main())

package/xflow/atoms/e6_gate_local_precheck.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""
+E6.gate.local_precheck — Atom entry point.
+Single source of truth for all deterministic phase gate checks.
+Wraps yolo_gate.py verbatim. Both yolo driver and agentos heavy workflow
+route through this script for structural checks.
+
+E6 ≡ E1+E2 invariant: agentos's local-workflow.js must NOT re-implement
+these checks; it must shell out here.
+"""
+import sys
+import os
+import subprocess
+
+def main():
+    # Forward all args to the real implementation
+    script = os.path.join(os.path.dirname(__file__), '..', 'yolo', 'scripts', 'yolo_gate.py')
+    script = os.path.abspath(script)
+    result = subprocess.run([sys.executable, script] + sys.argv[1:])
+    sys.exit(result.returncode)
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/h1_design_lite_gate.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""
+H1.design.lite_gate — Deterministic DESIGN.md sanity check.
+Checks for required section headings: Reference Anchors, Beauty Contract, Layout Premise.
+Does NOT invoke any LLM. Returns JSON verdict.
+"""
+import sys, os, json, argparse
+
+REQUIRED_SECTIONS = [
+    'Reference Anchors',
+    'Anti-References',
+    'Layout Premise',
+    'Beauty Contract',
+    'Failure Modes',
+]
+
+MINIMAL_SECTIONS = [
+    'Visual Tone',
+    'Color System',
+    'Typography',
+]
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--project-root', default='.')
+    p.add_argument('--change-id')
+    p.add_argument('--require-full-contract', action='store_true')
+    args = p.parse_args()
+
+    # Check project-level DESIGN.md first, then change-scoped design.md
+    design_md = os.path.join(args.project_root, 'DESIGN.md')
+    change_design_md = None
+    if args.change_id:
+        change_design_md = os.path.join(args.project_root, 'specs', 'changes', args.change_id, 'design.md')
+
+    target = change_design_md if (change_design_md and os.path.exists(change_design_md)) else design_md
+
+    if not os.path.exists(target):
+        result = {
+            'ok': False,
+            'gate': 'H1.design.lite_gate',
+            'verdict': 'missing',
+            'message': f'No DESIGN.md or design.md found at {target}',
+            'path': target,
+        }
+        print(json.dumps(result))
+        sys.exit(1)
+
+    content = open(target).read()
+    missing = []
+
+    if args.require_full_contract:
+        sections = REQUIRED_SECTIONS
+    else:
+        sections = MINIMAL_SECTIONS
+
+    for sec in sections:
+        if sec not in content:
+            missing.append(sec)
+
+    ok = len(missing) == 0
+    result = {
+        'ok': ok,
+        'gate': 'H1.design.lite_gate',
+        'verdict': 'pass' if ok else 'fail',
+        'path': target,
+        'missing_sections': missing,
+        'checked_sections': sections,
+    }
+    print(json.dumps(result))
+    sys.exit(0 if ok else 1)
+
+if __name__ == '__main__':
+    main()

package/xflow/atoms/i6a_tdd_run.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+I6a.tdd.run — Deterministic test runner harness.
+Runs a test command, captures exit code + truncated stdout,
+writes proof to specs/changes/<id>/tdd/<phase>-<n>.json.
+
+The harness is deterministic and records whether the raw test result met the
+phase expectation. Red expects a failing test; green/refactor expect passing tests.
+The proof also binds a snapshot of the tree so I6b can recompute the digest
+and re-run the command.
+"""
+import sys, os, json, argparse, subprocess, time
+from datetime import datetime, timezone
+from pathlib import Path
+
+import tdd_lib
+
+
+def default_expectation(phase: str) -> str:
+    return 'fail' if phase == 'red' else 'pass'
+
+def expectation_met(expect: str, passed: bool) -> bool:
+    if expect == 'fail':
+        return not passed
+    return passed
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--project-root', default='.')
+    p.add_argument('--change-id', required=True)
+    p.add_argument('--test-command', required=True, help='Test command to run')
+    p.add_argument('--phase', default='run', help='red | green | refactor | run')
+    p.add_argument('--attempt', type=int, default=0)
+    p.add_argument('--expect', choices=['pass', 'fail'], help='Expected raw test result')
+    args = p.parse_args()
+    expect = args.expect or default_expectation(args.phase)
+    project = Path(args.project_root).resolve()
+
+    proof_dir = os.path.join(args.project_root, 'specs', 'changes', args.change_id, 'tdd')
+    os.makedirs(proof_dir, exist_ok=True)
+
+    start = time.time()
+    timed_out = False
+    try:
+        result = subprocess.run(
+            args.test_command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            cwd=args.project_root,
+            timeout=300,
+            env=tdd_lib.test_env(),
+        )
+        elapsed = time.time() - start
+        stdout = result.stdout or ''
+        stderr = result.stderr or ''
+        exit_code = result.returncode
+    except subprocess.TimeoutExpired:
+        timed_out = True
+        elapsed = 300
+        stdout = ''
+        stderr = 'TIMEOUT after 300s'
+        exit_code = -1
+
+    passed = exit_code == 0
+    combined = f"{stdout}\n{stderr}"
+    file_hashes, snapshot_scope = tdd_lib.write_snapshot(
+        project, args.change_id, args.phase, args.attempt, command=args.test_command
+    )
+    proof = {
+        'phase': args.phase,
+        'attempt': args.attempt,
+        'command': args.test_command,
+        'exit_code': exit_code,
+        'passed': passed,
+        'expected': expect,
+        'expectation_met': expectation_met(expect, False if timed_out else passed),
+        'stdout_tail': stdout[-2000:] if stdout else '',
+        'stderr_tail': stderr[-1000:] if stderr else '',
+        'elapsed_s': round(elapsed, 2),
+        'output_sha256': tdd_lib.output_digest(stdout, stderr),
+        'git_head': tdd_lib.git_head(project),
+        'file_hashes': file_hashes,
+        'snapshot_scope': snapshot_scope,
+        'failure_kind': 'timeout' if timed_out else tdd_lib.classify_output(combined, passed),
+        'recorded_at': datetime.now(timezone.utc).isoformat(),
+    }
+    proof['binding'] = tdd_lib.compute_binding(proof)
+
+    proof_file = os.path.join(proof_dir, f'{args.phase}-{args.attempt}.json')
+    with open(proof_file, 'w') as f:
+        json.dump(proof, f, indent=2)
+        f.write('\n')
+
+    print(json.dumps({
+        'ok': proof['expectation_met'],
+        'proof_file': proof_file,
+        'exit_code': proof['exit_code'],
+        'expected': expect,
+        'passed': proof['passed'],
+        'failure_kind': proof['failure_kind'],
+        'binding': proof['binding'],
+    }))
+    sys.exit(0 if proof['expectation_met'] else 1)
+
+if __name__ == '__main__':
+    main()