chore: import upstream snapshot with attribution

scripts/test_swarm.py

@@ -0,0 +1,524 @@
+#!/usr/bin/env python3
+"""
+Test swarm coordination features via the debug socket.
+
+Uses debug commands directly (not tool:communicate) to avoid
+blocking I/O issues with the main socket.
+
+Tests:
+1. Coordinator election (first-created session gets coordinator)
+2. Communication (broadcast, DM via debug commands)
+3. Invalid DM recipient validation
+4. Swarm_id for non-git directories
+5. Plan approval workflow
+6. Plan rejection workflow
+7. Coordinator-only approval enforcement
+"""
+
+import socket
+import json
+import os
+import sys
+import time
+
+DEBUG_SOCKET = f"/run/user/{os.getuid()}/jcode-debug.sock"
+TEST_DIR = "/tmp/swarm-test"
+
+
+def send_cmd(cmd: str, session_id: str = None, timeout: float = 30) -> tuple:
+    """Send a debug command and get response. Returns (ok, output, error)."""
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    sock.connect(DEBUG_SOCKET)
+    sock.settimeout(timeout)
+
+    req = {"type": "debug_command", "id": 1, "command": cmd}
+    if session_id:
+        req["session_id"] = session_id
+
+    sock.send((json.dumps(req) + '\n').encode())
+
+    data = b""
+    while True:
+        chunk = sock.recv(65536)
+        if not chunk:
+            break
+        data += chunk
+        if b'\n' in data:
+            break
+
+    sock.close()
+    resp = json.loads(data.decode().strip())
+    return resp.get('ok', False), resp.get('output', ''), resp.get('error', '')
+
+
+def create_session(working_dir: str = TEST_DIR) -> str:
+    """Create a new session and return its ID."""
+    ok, output, err = send_cmd(f"create_session:{working_dir}")
+    if not ok:
+        raise RuntimeError(f"Failed to create session: {err or output}")
+    return json.loads(output)['session_id']
+
+
+def destroy_session(session_id: str):
+    """Destroy a session."""
+    send_cmd(f"destroy_session:{session_id}")
+
+
+def get_swarm_id(path: str = TEST_DIR) -> str:
+    """Get the swarm_id for a directory."""
+    ok, output, _ = send_cmd(f"swarm:id:{path}")
+    if ok:
+        return json.loads(output).get('swarm_id', '')
+    return ''
+
+
+def get_coordinator(swarm_id: str) -> str:
+    """Get the coordinator session_id for a swarm."""
+    ok, output, _ = send_cmd("swarm:coordinators")
+    if ok:
+        coords = json.loads(output)
+        for c in coords:
+            if c['swarm_id'] == swarm_id:
+                return c['coordinator_session']
+    return ''
+
+
+def test_coordinator_election():
+    """Test that the first-created session becomes coordinator."""
+    print("\n" + "=" * 60)
+    print("Test: Coordinator Election")
+    print("=" * 60)
+
+    os.makedirs(TEST_DIR, exist_ok=True)
+
+    s1 = create_session()
+    s2 = create_session()
+    swarm_id = get_swarm_id()
+
+    print(f"Session 1 (first): {s1[:20]}...")
+    print(f"Session 2 (second): {s2[:20]}...")
+
+    # First-created session should be coordinator
+    actual_coordinator = get_coordinator(swarm_id)
+    print(f"Actual coordinator: {actual_coordinator[:20]}...")
+
+    success = actual_coordinator == s1
+    if success:
+        print("✓ First-created session is the coordinator")
+    else:
+        print("✗ Coordinator is not the first-created session")
+
+    # Also verify via swarm:roles
+    ok, output, _ = send_cmd("swarm:roles")
+    if ok:
+        roles = json.loads(output)
+        coord_roles = [r for r in roles if r.get('is_coordinator')]
+        if coord_roles:
+            print(f"  Role-based coordinator: {coord_roles[0]['session_id'][:20]}...")
+        else:
+            print("  Warning: No coordinator found via swarm:roles")
+
+    destroy_session(s1)
+    destroy_session(s2)
+    return success
+
+
+def test_communication():
+    """Test broadcast and DM communication via debug commands."""
+    print("\n" + "=" * 60)
+    print("Test: Communication (broadcast, DM, members)")
+    print("=" * 60)
+
+    os.makedirs(TEST_DIR, exist_ok=True)
+
+    s1 = create_session()
+    s2 = create_session()
+    swarm_id = get_swarm_id()
+
+    print(f"Session 1: {s1[:20]}...")
+    print(f"Session 2: {s2[:20]}...")
+
+    success = True
+
+    # Test broadcast
+    ok, output, err = send_cmd(f"swarm:broadcast:{swarm_id} Hello swarm!", s1)
+    print(f"Broadcast: ok={ok}")
+    if ok:
+        data = json.loads(output)
+        print(f"  Sent to {data.get('sent_to', 0)} members")
+    else:
+        print(f"  Error: {err or output}")
+        success = False
+
+    # Test DM (notify)
+    ok, output, err = send_cmd(f"swarm:notify:{s2} Hello agent!", s1)
+    print(f"DM: ok={ok}")
+    if ok:
+        data = json.loads(output)
+        print(f"  Sent to: {data.get('sent_to', '')[:20]}...")
+    else:
+        print(f"  Error: {err or output}")
+        success = False
+
+    # Test list members
+    ok, output, err = send_cmd("swarm:members")
+    print(f"Members list: ok={ok}")
+    if ok:
+        members = json.loads(output)
+        member_ids = [m['session_id'] for m in members]
+        if s1 in member_ids and s2 in member_ids:
+            print(f"  Both sessions found in {len(members)} members")
+        else:
+            print("  ✗ Missing sessions in member list")
+            success = False
+
+    destroy_session(s1)
+    destroy_session(s2)
+
+    if success:
+        print("✓ Communication tests passed")
+    else:
+        print("✗ Communication tests had failures")
+    return success
+
+
+def test_invalid_dm():
+    """Test that DM to non-existent session returns error."""
+    print("\n" + "=" * 60)
+    print("Test: Invalid DM Recipient")
+    print("=" * 60)
+
+    os.makedirs(TEST_DIR, exist_ok=True)
+
+    s1 = create_session()
+    print(f"Session: {s1[:20]}...")
+
+    fake_session = "nonexistent_session_12345"
+    ok, output, err = send_cmd(f"swarm:notify:{fake_session} Hello?", s1)
+
+    print(f"DM to fake session: ok={ok}")
+    combined = (err + output).lower()
+    if not ok:
+        print(f"  Error (expected): {output[:80]}")
+
+    success = not ok and ("unknown session" in combined or "not in swarm" in combined)
+
+    destroy_session(s1)
+
+    if success:
+        print("✓ Invalid DM correctly rejected")
+    else:
+        print("✗ Invalid DM was not properly rejected")
+    return success
+
+
+def test_swarm_id_non_git():
+    """Test that non-git directories get a raw path swarm_id (not .git-based)."""
+    print("\n" + "=" * 60)
+    print("Test: Non-Git Directory Swarm ID")
+    print("=" * 60)
+
+    non_git_dir = "/tmp/non-git-test"
+    os.makedirs(non_git_dir, exist_ok=True)
+
+    import shutil
+    git_dir = os.path.join(non_git_dir, ".git")
+    if os.path.exists(git_dir):
+        shutil.rmtree(git_dir)
+
+    try:
+        s1 = create_session(non_git_dir)
+        print(f"Session: {s1[:20]}...")
+
+        # Check swarm:id — non-git dirs get raw path, is_git_repo=false
+        ok, output, _ = send_cmd(f"swarm:id:{non_git_dir}")
+        print(f"Swarm ID check: ok={ok}")
+        not_git = False
+        if ok:
+            data = json.loads(output)
+            not_git = data.get('is_git_repo') == False
+            print(f"  swarm_id: {data.get('swarm_id')}")
+            print(f"  is_git_repo: {data.get('is_git_repo')}")
+            print(f"  source: {data.get('source')}")
+
+        # Verify the session's swarm_id doesn't contain .git
+        ok2, output2, _ = send_cmd(f"swarm:session:{s1}")
+        no_git_in_swarm = False
+        if ok2:
+            sess_data = json.loads(output2)
+            swarm_id = sess_data.get('swarm_id') or ''
+            no_git_in_swarm = '.git' not in swarm_id
+            print(f"  Session swarm_id: {swarm_id}")
+
+        destroy_session(s1)
+
+        success = not_git and no_git_in_swarm
+        if success:
+            print("✓ Non-git directory correctly identified")
+        else:
+            print("✗ Non-git directory handling incorrect")
+        return success
+
+    except Exception as e:
+        print(f"✗ Error: {e}")
+        return False
+
+
+def test_plan_approval():
+    """Test plan proposal and approval workflow."""
+    print("\n" + "=" * 60)
+    print("Test: Plan Approval Workflow")
+    print("=" * 60)
+
+    os.makedirs(TEST_DIR, exist_ok=True)
+
+    s1 = create_session()
+    s2 = create_session()
+    swarm_id = get_swarm_id()
+    coordinator = get_coordinator(swarm_id)
+    agent = s2 if coordinator == s1 else s1
+
+    print(f"Coordinator: {coordinator[:20]}...")
+    print(f"Agent: {agent[:20]}...")
+
+    success = True
+
+    # Get plan item count before approval
+    ok, output, _ = send_cmd(f"swarm:plan_version:{swarm_id}")
+    items_before = 0
+    if ok:
+        items_before = json.loads(output).get('item_count', 0)
+        print(f"Plan items before: {items_before}")
+
+    # Agent proposes a plan via shared context
+    plan_items = [
+        {"id": "approval_test_1", "content": "Implement feature X", "status": "pending", "priority": "normal"}
+    ]
+    plan_json = json.dumps(plan_items)
+    proposal_key = f"plan_proposal:{agent}"
+
+    ok, output, err = send_cmd(
+        f"swarm:set_context:{agent} {proposal_key} {plan_json}"
+    )
+    print(f"Plan proposal shared: ok={ok}")
+    if not ok:
+        print(f"  Error: {err or output}")
+        success = False
+
+    # Verify proposal is in context
+    ok, output, err = send_cmd(f"swarm:context:{swarm_id}:{proposal_key}")
+    print(f"Read proposal: ok={ok}")
+    if not ok:
+        print(f"  Error: {err or output}")
+        success = False
+
+    # Coordinator approves
+    ok, output, err = send_cmd(f"swarm:approve_plan:{coordinator} {agent}")
+    print(f"Approve plan: ok={ok}")
+    if ok:
+        data = json.loads(output)
+        print(f"  Items added: {data.get('items_added')}")
+        print(f"  Plan version: {data.get('plan_version')}")
+    else:
+        print(f"  Error: {err or output}")
+        success = False
+
+    # Verify proposal was removed from context
+    ok, _, _ = send_cmd(f"swarm:context:{swarm_id}:{proposal_key}")
+    proposal_removed = not ok
+    print(f"Proposal removed after approval: {proposal_removed}")
+    if not proposal_removed:
+        print("  ✗ Proposal still exists after approval")
+        success = False
+
+    # Verify plan grew
+    ok, output, _ = send_cmd(f"swarm:plan_version:{swarm_id}")
+    if ok:
+        data = json.loads(output)
+        items_after = data.get('item_count', 0)
+        print(f"Plan items after: {items_after} (was {items_before})")
+        if items_after <= items_before:
+            print("  ✗ Plan did not grow after approval")
+            success = False
+
+    destroy_session(s1)
+    destroy_session(s2)
+
+    if success:
+        print("✓ Plan approval workflow completed successfully")
+    else:
+        print("✗ Plan approval workflow had failures")
+    return success
+
+
+def test_plan_rejection():
+    """Test plan rejection workflow."""
+    print("\n" + "=" * 60)
+    print("Test: Plan Rejection Workflow")
+    print("=" * 60)
+
+    os.makedirs(TEST_DIR, exist_ok=True)
+
+    s1 = create_session()
+    s2 = create_session()
+    swarm_id = get_swarm_id()
+    coordinator = get_coordinator(swarm_id)
+    agent = s2 if coordinator == s1 else s1
+
+    print(f"Coordinator: {coordinator[:20]}...")
+    print(f"Agent: {agent[:20]}...")
+
+    success = True
+
+    # Get plan version before
+    ok, output, _ = send_cmd(f"swarm:plan_version:{swarm_id}")
+    version_before = 0
+    if ok:
+        version_before = json.loads(output).get('version', 0)
+
+    # Share a plan proposal
+    plan_items = [{"id": "reject_test_1", "content": "Bad idea", "status": "pending", "priority": "normal"}]
+    plan_json = json.dumps(plan_items)
+    proposal_key = f"plan_proposal:{agent}"
+
+    ok, _, err = send_cmd(f"swarm:set_context:{agent} {proposal_key} {plan_json}")
+    print(f"Plan proposal shared: ok={ok}")
+    if not ok:
+        print(f"  Error: {err}")
+        success = False
+
+    # Coordinator rejects the plan
+    ok, output, err = send_cmd(
+        f"swarm:reject_plan:{coordinator} {agent} Not aligned with goals"
+    )
+    print(f"Reject plan: ok={ok}")
+    if ok:
+        data = json.loads(output)
+        print(f"  Rejected: {data.get('rejected')}")
+    else:
+        print(f"  Error: {err or output}")
+        success = False
+
+    # Verify proposal was removed
+    ok, _, _ = send_cmd(f"swarm:context:{swarm_id}:{proposal_key}")
+    proposal_removed = not ok
+    print(f"Proposal removed after rejection: {proposal_removed}")
+    if not proposal_removed:
+        success = False
+
+    # Verify plan version didn't change (rejected plans don't modify the plan)
+    ok, output, _ = send_cmd(f"swarm:plan_version:{swarm_id}")
+    if ok:
+        version_after = json.loads(output).get('version', 0)
+        plan_unchanged = version_after == version_before
+        print(f"Plan version unchanged: {plan_unchanged} ({version_before} → {version_after})")
+        if not plan_unchanged:
+            success = False
+
+    destroy_session(s1)
+    destroy_session(s2)
+
+    if success:
+        print("✓ Plan rejection workflow completed successfully")
+    else:
+        print("✗ Plan rejection workflow had failures")
+    return success
+
+
+def test_coordinator_only_approval():
+    """Test that non-coordinators cannot approve plans."""
+    print("\n" + "=" * 60)
+    print("Test: Coordinator-Only Approval")
+    print("=" * 60)
+
+    os.makedirs(TEST_DIR, exist_ok=True)
+
+    s1 = create_session()
+    s2 = create_session()
+    swarm_id = get_swarm_id()
+    coordinator = get_coordinator(swarm_id)
+    non_coordinator = s2 if coordinator == s1 else s1
+
+    print(f"Coordinator: {coordinator[:20]}...")
+    print(f"Non-coordinator: {non_coordinator[:20]}...")
+
+    # Try to approve from non-coordinator
+    ok, output, err = send_cmd(
+        f"swarm:approve_plan:{non_coordinator} {coordinator}"
+    )
+    print(f"Non-coordinator approve attempt: ok={ok}")
+    if not ok:
+        print(f"  Error (expected): {output[:80]}")
+
+    combined = (err + output).lower()
+    success = not ok and "coordinator" in combined
+
+    destroy_session(s1)
+    destroy_session(s2)
+
+    if success:
+        print("✓ Non-coordinator approval correctly rejected")
+    else:
+        print("✗ Non-coordinator was not properly rejected")
+    return success
+
+
+def main():
+    """Run all tests."""
+    print("=" * 60)
+    print("Swarm Integration Tests")
+    print("=" * 60)
+
+    if not os.path.exists(DEBUG_SOCKET):
+        print(f"Error: Debug socket not found: {DEBUG_SOCKET}")
+        print("Make sure jcode server is running with debug_control enabled:")
+        print("  touch ~/.jcode/debug_control")
+        print("  jcode serve")
+        sys.exit(1)
+
+    results = []
+
+    tests = [
+        ("Coordinator Election", test_coordinator_election),
+        ("Communication", test_communication),
+        ("Invalid DM", test_invalid_dm),
+        ("Non-Git Swarm ID", test_swarm_id_non_git),
+        ("Plan Approval", test_plan_approval),
+        ("Plan Rejection", test_plan_rejection),
+        ("Coordinator-Only Approval", test_coordinator_only_approval),
+    ]
+
+    for name, test_fn in tests:
+        try:
+            result = test_fn()
+            results.append((name, result))
+        except Exception as e:
+            print(f"✗ {name} failed with exception: {e}")
+            import traceback
+            traceback.print_exc()
+            results.append((name, False))
+
+    # Summary
+    print("\n" + "=" * 60)
+    print("Summary")
+    print("=" * 60)
+
+    passed = sum(1 for _, r in results if r)
+    total = len(results)
+
+    for name, result in results:
+        status = "✓ PASS" if result else "✗ FAIL"
+        print(f"  {status}: {name}")
+
+    print(f"\n{passed}/{total} tests passed")
+
+    if passed == total:
+        print("\nAll tests passed!")
+        sys.exit(0)
+    else:
+        print("\nSome tests failed.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()