onecoder 0.0.2__tar.gz → 0.0.4__tar.gz

{onecoder-0.0.2 → onecoder-0.0.4}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: onecoder
-Version: 0.0.2
+Version: 0.0.4
 Requires-Python: >=3.11
 Requires-Dist: google-adk
 Requires-Dist: litellm
 Requires-Dist: python-dotenv
-Requires-Dist: rank_bm25
+Requires-Dist: rank-bm25
 Requires-Dist: fastapi>=0.104.0
 Requires-Dist: uvicorn[standard]>=0.24.0
 Requires-Dist: httpx>=0.25.0
@@ -13,5 +13,9 @@ Requires-Dist: rich>=13.0.0
 Requires-Dist: textual>=0.50.0
 Requires-Dist: click>=8.1.0
 Requires-Dist: requests>=2.31.0
+Requires-Dist: python-frontmatter>=1.0.0
+Requires-Dist: pluggy>=1.0.0
+Requires-Dist: jsonschema>=4.0.0
 Requires-Dist: pytest>=7.4.0
 Requires-Dist: pytest-asyncio>=0.21.0
+Requires-Dist: twine

onecoder-0.0.4/ai_sprint/__init__.py

@@ -0,0 +1 @@
+"""AI Sprint CLI - Sprint lifecycle management and state tracking."""

onecoder-0.0.4/ai_sprint/cli.py

@@ -0,0 +1,40 @@
+import click
+import sys
+from .commands import common, sprint, task, governance, utility
+
+@click.group()
+@click.version_option(version="0.1.4")
+def main():
+    """ai-sprint: Standardize your development sprints."""
+    pass
+
+def run():
+    """Main entry point with telemetry wrapper."""
+    try:
+        main()
+    except Exception as e:
+        if isinstance(e, (click.exceptions.Exit, click.exceptions.Abort, click.exceptions.ClickException)):
+            raise e
+        from .telemetry import FailureModeCapture
+        capture = FailureModeCapture(common.PROJECT_ROOT)
+        capture.capture(e, context={"command_args": sys.argv[1:]})
+        raise e
+
+# Register commands
+main.add_command(sprint.init)
+main.add_command(sprint.update)
+main.add_command(sprint.status)
+main.add_command(task.start)
+main.add_command(task.finish)
+main.add_command(governance.commit)
+main.add_command(governance.verify)
+main.add_command(governance.preflight)
+main.add_command(governance.close)
+main.add_command(utility.trace)
+main.add_command(utility.audit)
+main.add_command(utility.backlog)
+main.add_command(utility.check_submodules, name="check-submodules")
+main.add_command(utility.install_hooks, name="install-hooks")
+
+if __name__ == "__main__":
+    main()

onecoder-0.0.4/ai_sprint/commands/common.py

@@ -0,0 +1,37 @@
+import os
+import sys
+from pathlib import Path
+
+class LazyConsole:
+    def __init__(self):
+        self._console = None
+
+    @property
+    def inner(self):
+        if self._console is None:
+            from rich.console import Console
+            self._console = Console()
+        return self._console
+
+    def print(self, *args, **kwargs):
+        self.inner.print(*args, **kwargs)
+
+    def __getattr__(self, name):
+        return getattr(self.inner, name)
+
+console = LazyConsole()
+
+def find_project_root():
+    """Find the project root directory (containing .git)."""
+    current = Path.cwd()
+    while current != current.parent:
+        if (current / ".git").exists():
+            return current
+        current = current.parent
+    return Path.cwd()
+
+PROJECT_ROOT = find_project_root()
+SPRINT_DIR = PROJECT_ROOT / ".sprint"
+
+from ..state import SprintStateManager
+from ..commit import auto_detect_sprint_id

onecoder-0.0.4/ai_sprint/commands/governance.py

@@ -0,0 +1,327 @@
+import click
+import json
+import os
+import re
+import subprocess
+import sys
+import shutil
+from pathlib import Path
+from typing import List, Dict, Any
+from .common import console, PROJECT_ROOT, SPRINT_DIR, SprintStateManager, auto_detect_sprint_id
+from ..commit import validate_trailers, create_commit_with_trailers
+from ..spec_validator import validate_spec_ids
+from ..trace import trace_specifications
+from ..preflight import SprintPreflight
+from ..policy import PolicyEngine
+
+@click.command()
+@click.option("--message", "-m", required=True, help="Commit message")
+@click.option("--task-id", help="Task identifier")
+@click.option("--status", type=click.Choice(["planning", "in-progress", "review", "done"]), help="Task status")
+@click.option("--validation", help="Validation status or URI")
+@click.option("--sprint-id", help="Override sprint ID")
+@click.option("--spec-id", help="Specification ID(s)")
+@click.option("--component", help="Component scope")
+@click.option("--files", "-f", help="Files to stage (comma-separated or multiple)")
+def commit(message, task_id, status, validation, sprint_id, spec_id, component, files):
+    """Create atomic commit with metadata trailers."""
+    trailers = {}
+    active_sprint_id = sprint_id or auto_detect_sprint_id()
+    if active_sprint_id:
+        trailers["Sprint-Id"] = active_sprint_id
+        if not component:
+            try:
+                state_manager = SprintStateManager(SPRINT_DIR / active_sprint_id)
+                component = state_manager.get_component()
+            except Exception: pass
+    if component: trailers["Component"] = component
+    
+    if task_id:
+        if not re.match(r"^task-\d+$", task_id):
+            resolved = None
+            if active_sprint_id:
+                try:
+                    state_manager = SprintStateManager(SPRINT_DIR / active_sprint_id)
+                    resolved = state_manager.get_task_id_by_title(task_id)
+                except Exception: pass
+            if not resolved and task_id.isdigit():
+                resolved = f"task-{int(task_id):03d}"
+            if resolved:
+                console.print(f"[dim]Resolved Task ID: {task_id} -> {resolved}[/dim]")
+                task_id = resolved
+        trailers["Task-Id"] = task_id
+
+    if status:
+        if status == "done":
+            try:
+                result = subprocess.run(["git", "diff", "--cached", "--name-only"], capture_output=True, text=True, check=True)
+                staged_files = [f.strip() for f in result.stdout.split("\n") if f.strip()]
+                has_impl_changes = any(not (f.startswith(".sprint/") or f in ["TODO.md", "RETRO.md", "README.md", "sprint.json"]) for f in staged_files)
+                is_exception = any(x in message.lower() for x in ["docs", "chore", "governance"])
+                if not has_impl_changes and not is_exception:
+                    console.print("[bold red]Error:[/bold red] Implementation Integrity Violation (SPEC-GOV-008.2)")
+                    sys.exit(1)
+            except Exception: pass
+        trailers["Status"] = status
+
+    if validation: trailers["Validation"] = validation
+    if spec_id:
+        is_valid, errors = validate_spec_ids(spec_id, PROJECT_ROOT)
+        if not is_valid:
+            for error in errors: console.print(f"  ❌ {error}")
+            sys.exit(1)
+        trailers["Spec-Id"] = spec_id
+
+    errors = validate_trailers(trailers)
+    if errors:
+        for error in errors: console.print(f"  ❌ {error}")
+        sys.exit(1)
+
+    # Automatically stage files if provided
+    file_list = []
+    if files:
+        # Support comma-separated or multiple (though click argument is single for now)
+        file_list = [f.strip() for f in files.split(",") if f.strip()]
+        if file_list:
+            console.print(f"[dim]Staging files: {', '.join(file_list)}[/dim]")
+            try:
+                subprocess.run(["git", "add"] + file_list, cwd=PROJECT_ROOT, check=True)
+            except subprocess.CalledProcessError as e:
+                console.print(f"[bold red]Error staging files:[/bold red] {e}")
+                sys.exit(1)
+
+    from ..submodule import get_unpushed_submodules
+    if get_unpushed_submodules(PROJECT_ROOT):
+        console.print("[bold red]Error:[/bold red] Unpushed submodule commits detected.")
+        sys.exit(1)
+
+    # ProbLLM Governance Check on Staged Files
+    try:
+        # Import dynamically to avoid circular dependencies if any, or just standard import
+        from onecoder.governance.probllm import ProbLLMGuardian
+        guardian = ProbLLMGuardian(PROJECT_ROOT / "governance.yaml")
+        
+        # Re-fetch staged files as they might have changed if 'files' arg was used
+        res = subprocess.run(["git", "diff", "--cached", "--name-only"], capture_output=True, text=True)
+        if res.returncode == 0:
+            current_staged = [f.strip() for f in res.stdout.split("\n") if f.strip()]
+            is_safe, msg = guardian.validate_staged_files(current_staged)
+            if not is_safe:
+                console.print(f"[bold red]Governance Block (ProbLLM):[/bold red] {msg}")
+                sys.exit(1)
+    except ImportError:
+        # If onecoder package is not found (e.g. running ai-sprint standalone), skip or warn
+        # For now, we assume implicit availability in the onecoder-cli environment
+        pass
+    except Exception as e:
+        console.print(f"[yellow]Warning:[/yellow] ProbLLM check failed to run: {e}")
+
+    if create_commit_with_trailers(message, trailers):
+        console.print("[bold green]Success:[/bold green] Commit created.")
+    else:
+        sys.exit(1)
+
+@click.command()
+@click.option("--sprint-id", help="Override sprint ID")
+def verify(sprint_id):
+    """Verify sprint for technical debt (Zero Errors/Lint)."""
+    active_sprint = sprint_id or auto_detect_sprint_id()
+    if not active_sprint:
+        console.print("[bold red]Error:[/bold red] No active sprint detected.")
+        sys.exit(1)
+    target_dir = SPRINT_DIR / active_sprint
+    state_manager = SprintStateManager(target_dir)
+    component = state_manager.get_component()
+    if not component:
+        console.print("[yellow]Warning:[/yellow] No component scope defined.")
+        return
+
+    console.print(f"[cyan]Verifying component debt for [bold]{component}[/bold]...[/cyan]")
+    policy_engine = PolicyEngine(PROJECT_ROOT)
+    comp_rules = policy_engine.get_verification_rules().get(component, [])
+    
+    results = {"errors": 0, "lint_violations": 0, "details": []}
+    for check in comp_rules:
+        cmd = check if isinstance(check, str) else check['cmd']
+        name = check if isinstance(check, str) else check['name']
+        res = subprocess.run(cmd, shell=True, cwd=PROJECT_ROOT / component, capture_output=True, text=True)
+        if res.returncode != 0:
+            results["errors" if "lint" not in name.lower() else "lint_violations"] += 1
+            console.print(f"  ❌ [bold red]{name} failed[/bold red]")
+        else:
+            console.print(f"  ✅ [green]{name} passed[/green]")
+    
+    with open(target_dir / ".verification_results.json", "w") as f:
+        json.dump(results, f)
+    if results["errors"] > 0 or results["lint_violations"] > 0:
+        sys.exit(1)
+    console.print("\n[bold green]✓ Zero-Debt Verification Passed.[/bold green]")
+
+@click.command()
+@click.option("--fix", is_flag=True, help="Attempt to fix simple issues")
+@click.option("--sprint-id", help="Sprint ID to preflight")
+def preflight(fix, sprint_id):
+    """Validate sprint readiness and governance adherence."""
+    active_sprint = sprint_id or auto_detect_sprint_id()
+    if not active_sprint:
+        console.print("[bold red]Error:[/bold red] No active sprint detected.")
+        return
+    sprint_dir = SPRINT_DIR / active_sprint
+    preflight_engine = SprintPreflight(sprint_dir, PROJECT_ROOT)
+    score, results = preflight_engine.run_all()
+    for res in results:
+        status_icon = "✅" if res["status"] == "passed" else ("❌" if res["status"] == "failed" else "⚠️")
+        color = "green" if res["status"] == "passed" else ("red" if res["status"] == "failed" else "yellow")
+        console.print(f"  {status_icon} [{color}]{res['name']}[/{color}]: {res['message']}")
+    if score < 75: sys.exit(1)
+
+@click.command()
+@click.argument("name")
+@click.option("--pr/--no-pr", is_flag=True, default=True, help="Create pull request after closing sprint")
+@click.option("--apply", is_flag=True, help="Execute the closure (Apply phase)")
+@click.option("--plan", is_flag=True, default=True, help="Only show what would be done (Plan phase, default)")
+def close(name, pr, apply, plan):
+    """Close a sprint if criteria are met (Plan-Apply pattern)."""
+    from ..pr_creator import create_pull_request
+    from ..visual_generator import generate_visual_assets
+    from ..policy import PolicyEngine
+    
+    is_apply = apply
+    target_dir = SPRINT_DIR / name
+    if not target_dir.exists():
+        console.print(f"[bold red]Error:[/bold red] Sprint {name} does not exist.")
+        sys.exit(1)
+    
+    console.print(f"[cyan]Evaluating governance policy for {name}...[/cyan]")
+    policy_engine = PolicyEngine(PROJECT_ROOT)
+
+    visual_policy = policy_engine.get_visual_policy()
+    if visual_policy.get("auto_generate_on_close"):
+        media_dir = target_dir / "media"
+        if is_apply or media_dir.exists() or plan:
+             console.print(f"[cyan]Ensuring visual assets for {name}...[/cyan]")
+             try:
+                 generate_visual_assets(target_dir, name)
+             except Exception as e:
+                 if "Google IDE" not in str(e):
+                     console.print(f"[yellow]Warning:[/yellow] Visual generation issue: {e}")
+
+    closure_rules = policy_engine.get_closure_policy()
+    violations = policy_engine.evaluate_closure(target_dir)
+    has_debt = any("Zero-Debt" in v or "verification has not been run" in v for v in violations)
+
+    if closure_rules.get("require_zero_debt") and is_apply and has_debt:
+        console.print(f"[cyan]Verifying zero-debt status for {name}...[/cyan]")
+        try:
+            ctx = click.get_current_context()
+            ctx.invoke(verify, sprint_id=name)
+        except SystemExit as e:
+            if e.code != 0:
+                console.print("[bold red]Cannot close: Zero-Debt verification failed.[/bold red]")
+                sys.exit(1)
+        except Exception as e:
+            console.print(f"[yellow]Warning:[/yellow] Verification could not be run: {e}")
+
+    violations = policy_engine.evaluate_closure(target_dir)
+    if violations:
+        console.print("[bold red]Cannot close: Governance Policy Violations Detected![/bold red]")
+        for v in violations: console.print(f"  ❌ {v}")
+        if not is_apply: console.print("\n[dim]Tip: Run with --apply to attempt automatic fixes.[/dim]")
+        sys.exit(1)
+    
+    if not is_apply:
+        console.print("\n[bold cyan]--- Sprint Close PLAN ---[/bold cyan]")
+        console.print("[dim]Governance: OK[/dim]")
+    
+    from ..submodule import get_unpushed_submodules
+    if get_unpushed_submodules(PROJECT_ROOT):
+        console.print("[bold red]Cannot close:[/bold red] Unpushed submodule commits detected.")
+        sys.exit(1)
+
+    try:
+        # Check for staged changes
+        staged = subprocess.run(["git", "diff", "--cached", "--name-only"], capture_output=True, text=True, cwd=PROJECT_ROOT)
+        if staged.returncode == 0 and staged.stdout.strip():
+             console.print("[bold red]Cannot close:[/bold red] Found staged changes.")
+             sys.exit(1)
+
+        # Check for unstaged changes
+        result = subprocess.run(["git", "status", "--porcelain"], capture_output=True, text=True, cwd=PROJECT_ROOT)
+        if result.returncode == 0 and result.stdout.strip():
+            uncommitted_files = [f for f in result.stdout.strip().split("\n") 
+                                if not (f[3:].startswith(".sprint/") or f[3:].endswith(".json") or f[3:] in ["TODO.md", "RETRO.md", "README.md", "sprint.json"])]
+            if uncommitted_files:
+                console.print(f"[bold red]Cannot close:[/bold red] Found {len(uncommitted_files)} uncommitted implementation changes.")
+                sys.exit(1)
+    except Exception as e: console.print(f"[yellow]Warning:[/yellow] Git check: {e}")
+
+    # TODO.md check
+    todo_file = target_dir / "TODO.md"
+    if todo_file.exists():
+        with open(todo_file, "r") as f: lines = f.readlines()
+        delivery_sections = ["## High Priority", "## Implementation"]
+        in_delivery_section = True
+        incomplete_tasks = []
+        for line in lines:
+            if line.startswith("## "):
+                section_name = line.strip()
+                if section_name in delivery_sections: in_delivery_section = True
+                elif section_name in ["## Backlog", "## Future"]: in_delivery_section = False
+                else: in_delivery_section = "backlog" not in section_name.lower()
+            if in_delivery_section:
+                match = re.match(r"-\s*\[\s\]\s*(.+)", line)
+                if match and match.group(1).strip(): incomplete_tasks.append(match.group(1).strip())
+        if incomplete_tasks:
+            console.print(f"[bold red]Cannot close:[/bold red] Found {len(incomplete_tasks)} incomplete tasks.")
+            sys.exit(1)
+
+    retro_file = target_dir / "RETRO.md"
+    if not retro_file.exists() or retro_file.stat().st_size < 50:
+        console.print("[bold red]Cannot close:[/bold red] RETRO.md missing or too short.")
+        sys.exit(1)
+
+    # BAKE-IT check
+    try:
+        trace_map = trace_specifications(PROJECT_ROOT, limit=500)
+        sprint_flags = [f for f in trace_map.get("audit", []) if name in str(f.get("message", "")) or name == f.get("id") or (f.get("sprint_id") == name)]
+        if sprint_flags:
+            console.print("[bold red]Cannot close: BAKE-IT Anti-Patterns Detected![/bold red]")
+            sys.exit(1)
+    except Exception as e: console.print(f"[yellow]Warning:[/yellow] Audit check skipped: {e}")
+
+    if not is_apply:
+        console.print("\n[bold green]Plan phase complete.[/bold green]")
+        return
+
+    # Apply phase
+    (target_dir / ".status").write_text("Closed")
+    try:
+        to_add = [a for a in [str(target_dir.relative_to(PROJECT_ROOT)), "TODO.md", "RETRO.md", "README.md", "sprint.json"] if (PROJECT_ROOT / a).exists()]
+        if to_add:
+            subprocess.run(["git", "add"] + to_add, cwd=PROJECT_ROOT, check=True)
+            commit_msg = f"chore(gov): close sprint {name}\n\n[Sprint-Id: {name}]\n[Status: closed]"
+            subprocess.run(["git", "commit", "-m", commit_msg], cwd=PROJECT_ROOT, check=True)
+    except Exception as e: console.print(f"[yellow]Warning:[/yellow] Governance commit failed: {e}")
+
+    console.print(f"[bold green]Success:[/bold green] Sprint {name} closed.")
+    if pr:
+        try:
+            create_pull_request(target_dir, name)
+            console.print("[green]✓[/green] Pull request created")
+        except Exception as e: console.print(f"[bold red]Error:[/bold red] PR failed: {e}")
+
+@click.command()
+@click.option("--limit", default=100, help="Number of commits to trace")
+@click.option("--json", "json_output", is_flag=True, help="Output as JSON")
+def audit(limit, staged):
+    """Run a comprehensive audit on current project."""
+    # Placeholder for audit logic
+    pass
+
+@click.command()
+@click.option("--component", help="Filter by component")
+@click.option("--category", help="Filter by category")
+def backlog(component, category):
+    """View consolidated backlog."""
+    # Placeholder for backlog logic
+    pass

onecoder-0.0.4/ai_sprint/commands/sprint.py

@@ -0,0 +1,142 @@
+import click
+import re
+import subprocess
+from pathlib import Path
+from .common import console, PROJECT_ROOT, SPRINT_DIR, SprintStateManager, auto_detect_sprint_id
+
+def create_sprint_structure(target_dir: Path, name: str, exist_ok: bool = False):
+    target_dir.mkdir(parents=True, exist_ok=exist_ok)
+    (target_dir / "planning").mkdir(exist_ok=True)
+    (target_dir / "logs").mkdir(exist_ok=True)
+    (target_dir / "context").mkdir(exist_ok=True)
+    (target_dir / "media").mkdir(exist_ok=True)
+
+    readme_file = target_dir / "README.md"
+    if not readme_file.exists():
+        with open(readme_file, "w") as f:
+            f.write(f"# Sprint: {name}\n\n## Goal\nDescribe the goal of this sprint.\n")
+
+    tasks_file = target_dir / "planning" / "tasks.md"
+    if not tasks_file.exists():
+        with open(tasks_file, "w") as f:
+            f.write("# Tasks\n\n- [ ] Initial Task\n")
+
+    todo_file = target_dir / "TODO.md"
+    if not todo_file.exists():
+        with open(todo_file, "w") as f:
+            f.write("# Sprint TODO\n\n## High Priority\n- [ ] \n\n## Backlog\n- [ ] \n")
+
+    retro_file = target_dir / "RETRO.md"
+    if not retro_file.exists():
+        with open(retro_file, "w") as f:
+            f.write(
+                "# Retrospective\n\n"
+                "## Went Well\n\n"
+                "## To Improve\n\n"
+                "## Action Items\n\n"
+                "## Visual Assets\n"
+                "<!-- Generated diagrams and flowcharts will be referenced here -->\n"
+            )
+
+@click.command()
+@click.argument("name", required=False)
+@click.option("--name", "name_option", help="Name of the sprint directory")
+@click.option("--branch/--no-branch", default=True, help="Automatically create and switch to a git branch")
+@click.option("--component", help="Component scope for this sprint")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompts")
+def init(name, name_option, branch, component, yes):
+    """Initialize a new sprint directory structure."""
+    if not name:
+        name = name_option
+    if not name:
+        name = click.prompt("Sprint Name")
+
+    if not yes and not click.confirm("Have you reviewed the pending .issues/ and backlog?"):
+        console.print("[bold yellow]Aborted.[/bold yellow]")
+        return
+
+    if not re.match(r"^\d{3}-", name):
+        max_num = 0
+        if SPRINT_DIR.exists():
+            for item in SPRINT_DIR.iterdir():
+                if item.is_dir():
+                    match = re.match(r"^(\d{3})-", item.name)
+                    if match:
+                        num = int(match.group(1))
+                        if num > max_num:
+                            max_num = num
+        next_num = max_num + 1
+        name = f"{next_num:03d}-{name}"
+
+    target_dir = SPRINT_DIR / name
+    if target_dir.exists():
+        console.print(f"[bold red]Error:[/bold red] Directory {target_dir} already exists.")
+        return
+
+    try:
+        create_sprint_structure(target_dir, name)
+        state_manager = SprintStateManager(target_dir)
+        initial_state = state_manager.create_initial_state(name, name, component)
+        state_manager.save(initial_state)
+        console.print(f"[bold green]Success:[/bold green] Initialized sprint at [cyan]{target_dir}[/cyan]")
+
+        if branch:
+            branch_name = f"sprint/{name}"
+            subprocess.run(["git", "checkout", "-b", branch_name], check=True, capture_output=True)
+            console.print(f"[bold green]Success:[/bold green] Created branch [cyan]{branch_name}[/cyan]")
+
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] Failed to initialize: {e}")
+        return
+
+    console.print("\n[cyan]Running sprint preflight check...[/cyan]")
+    from ..preflight import SprintPreflight
+    preflight = SprintPreflight(target_dir, PROJECT_ROOT)
+    score, results = preflight.run_all()
+    
+    for res in results:
+        status_icon = "✅" if res["status"] == "passed" else ("❌" if res["status"] == "failed" else "⚠️")
+        color = "green" if res["status"] == "passed" else ("red" if res["status"] == "failed" else "yellow")
+        console.print(f"  {status_icon} [{color}]{res['name']}[/{color}]: {res['message']}")
+        
+    if score >= 75:
+        console.print(f"\n[bold green]Preflight Passed![/bold green] Score: {score}/100")
+    else:
+        console.print(f"\n[bold red]Preflight Failed![/bold red] Score: {score}/100")
+
+@click.command()
+@click.argument("name")
+def update(name):
+    """Update an existing sprint with missing templates."""
+    target_dir = SPRINT_DIR / name
+    if not target_dir.exists():
+        console.print(f"[bold red]Error:[/bold red] Sprint {name} does not exist.")
+        return
+    try:
+        create_sprint_structure(target_dir, name, exist_ok=True)
+        console.print(f"[bold green]Success:[/bold green] Updated sprint at {target_dir}")
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] Failed to update: {e}")
+
+@click.command()
+def status():
+    """Show the current status of the sprint."""
+    if not SPRINT_DIR.exists():
+        console.print("[yellow]No .sprint directory found.[/yellow]")
+        return
+
+    from rich.table import Table
+    table = Table(title="Available Sprints")
+    table.add_column("Sprint Name", style="cyan")
+    table.add_column("Status", style="magenta")
+
+    for item in sorted(SPRINT_DIR.iterdir()):
+        if item.is_dir():
+            status_file = item / ".status"
+            state = "Active"
+            if status_file.exists():
+                with open(status_file, "r") as f:
+                    state = f.read().strip()
+            color = "green" if state == "Active" else "dim white"
+            table.add_row(item.name, f"[{color}]{state}[/{color}]")
+    console.print(table)

onecoder-0.0.4/ai_sprint/commands/task.py

@@ -0,0 +1,79 @@
+import click
+import datetime
+import subprocess
+from pathlib import Path
+from typing import List, Dict
+from .common import console, PROJECT_ROOT, SPRINT_DIR, SprintStateManager, auto_detect_sprint_id
+
+def _validate_audit_task(task: Dict, sprint_commits: List[Dict], project_root: Path) -> bool:
+    from ..trace import get_commit_files
+    for commit in sprint_commits:
+        files = get_commit_files(commit["hash"], project_root)
+        if any(f.startswith(".issues/") for f in files):
+            return True
+    return False
+
+def _validate_artifact_task(task: Dict, sprint_commits: List[Dict], sprint_dir: Path, project_root: Path) -> bool:
+    from ..trace import get_commit_files
+    sprint_rel_path = sprint_dir.relative_to(project_root)
+    for commit in sprint_commits:
+        files = get_commit_files(commit["hash"], project_root)
+        if any(f.startswith(str(sprint_rel_path)) for f in files):
+            return True
+    return False
+
+@click.command()
+@click.argument("task_name")
+@click.option("--branch/--no-branch", default=True, help="Create/switch to a sprint branch")
+@click.option("--type", type=click.Choice(["implementation", "audit", "docs", "planning"]), help="Task type")
+def start(task_name, branch, type):
+    """Start working on a specific task."""
+    console.print(f"[bold blue]Starting task:[/bold blue] {task_name}")
+    active_sprint = auto_detect_sprint_id()
+    if not active_sprint:
+        console.print("[yellow]Warning:[/yellow] No active sprint detected.")
+    else:
+        sprint_dir = SPRINT_DIR / active_sprint
+        if sprint_dir.exists():
+            state_manager = SprintStateManager(sprint_dir)
+            if not type:
+                type = click.prompt("Task type", type=click.Choice(["implementation", "audit", "docs", "planning"]), default="implementation")
+            state = state_manager.load()
+            for task in state.get("tasks", []):
+                if task.get("id") == task_name or task.get("title") == task_name:
+                    task["status"] = "in-progress"
+                    task["type"] = type
+                    if not task.get("startedAt"):
+                        task["startedAt"] = datetime.datetime.now().isoformat()
+                    break
+            state_manager.save(state)
+            state_manager.start_task(task_name)
+    timestamp = datetime.datetime.now().isoformat()
+    console.print(f"Recorded start time: {timestamp}")
+
+@click.command()
+@click.argument("task_name", required=False)
+@click.option("--message", "-m", help="Commit message")
+@click.option("--validation", "-v", help="Validation proof (URI, path, or description)")
+def finish(task_name, message, validation):
+    """Finish the current task and commit changes with validation."""
+    if not task_name:
+        task_name = click.prompt("Finished Task Name/ID")
+    if not validation:
+        validation = click.prompt("Validation Proof")
+    if not message:
+        message = click.prompt("Commit Message", default=f"feat: finish task {task_name}")
+
+    console.print(f"[bold green]Finishing task:[/bold green] {task_name}")
+    active_sprint_id = auto_detect_sprint_id()
+    resolved_task_id = task_name
+    if active_sprint_id:
+        state_manager = SprintStateManager(SPRINT_DIR / active_sprint_id)
+        if state_manager.mark_done(task_name):
+            console.print(f"Task marked as [bold green]done[/bold green]")
+            id_lookup = state_manager.get_task_id_by_title(task_name)
+            if id_lookup: resolved_task_id = id_lookup
+    
+    from .governance import commit
+    ctx = click.get_current_context()
+    ctx.invoke(commit, message=message, task_id=resolved_task_id, status="done", validation=validation)