devcouncil 0.1.0 → 0.1.1

package/src/devcouncil/cli/commands/repair.py

@@ -1,69 +1,72 @@
-import typer
-from rich.console import Console
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import TaskRepository, GapRepository
-from devcouncil.planning.repair_service import RepairService
-from devcouncil.execution.context_builder import ContextBuilder
-from devcouncil.llm.provider import OpenRouterProvider
-from devcouncil.llm.router import ModelRouter
-from devcouncil.app.config import load_config, get_api_key
-import asyncio
-from pathlib import Path
-
-app = typer.Typer()
-console = Console()
-
-async def run_repair_flow():
-    db = get_db()
-    if not db:
-        console.print("[red]DevCouncil not initialized. Run 'dev init' first.[/red]")
-        return
-
-    with db.get_session() as session:
-        gap_repo = GapRepository(session)
-        task_repo = TaskRepository(session)
-
-        all_gaps = gap_repo.get_all()
-        blocking_gaps = [g for g in all_gaps if g.blocking]
-        
-        if not blocking_gaps:
-            console.print("[green]No blocking gaps found. Nothing to repair![/green]")
-            return
-
-        console.print(f"Found [bold]{len(blocking_gaps)}[/bold] blocking gaps. Orchestrating repair plan...")
-
-        # Load router
-        try:
-            config = load_config(Path("."))
-            api_key = get_api_key(config.models.provider)
-        except (FileNotFoundError, ValueError) as e:
-            console.print(f"[red]{e}[/red]")
-            return
-        
-        provider = OpenRouterProvider(api_key)
-        role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
-        router = ModelRouter(provider, role_config)
-        repair_service = RepairService(router)
-        context_builder = ContextBuilder(Path("."))
-        
-        # Build minimal context for repair.
-        project_context = context_builder.get_structure_summary()
-
-        repair_output = await repair_service.generate_repair_plan(blocking_gaps, str(project_context))
-        
-        for task in repair_output.suggested_tasks:
-            task.id = f"REPAIR-{task.id}"
-            task_repo.save(task)
-            console.print(f"  - Created intelligent repair task [bold]{task.id}[/bold]: {task.title}")
-
-        console.print(f"\n[green]Successfully generated {len(repair_output.suggested_tasks)} repair tasks.[/green]")
-
-@app.callback(invoke_without_command=True)
-def repair(ctx: typer.Context):
-    """
-    Convert blocking gaps into intelligent repair tasks using LLM inference.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    asyncio.run(run_repair_flow())
+import typer
+from rich.console import Console
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import TaskRepository, GapRepository
+from devcouncil.planning.repair_service import RepairService
+from devcouncil.execution.context_builder import ContextBuilder
+from devcouncil.llm.provider import create_provider, validate_model_provider
+from devcouncil.llm.router import ModelRouter
+from devcouncil.app.config import load_config, get_api_key
+from devcouncil.cli.commands.init import initialize_project
+import asyncio
+from pathlib import Path
+
+app = typer.Typer()
+console = Console()
+
+async def run_repair_flow():
+    initialize_project(Path("."), quiet=True)
+    db = get_db()
+    if not db:
+        console.print("[red]DevCouncil state is unavailable in this directory.[/red]")
+        return
+
+    with db.get_session() as session:
+        gap_repo = GapRepository(session)
+        task_repo = TaskRepository(session)
+
+        all_gaps = gap_repo.get_all()
+        blocking_gaps = [g for g in all_gaps if g.blocking]
+        
+        if not blocking_gaps:
+            console.print("[green]No blocking gaps found. Nothing to repair![/green]")
+            return
+
+        console.print(f"Found [bold]{len(blocking_gaps)}[/bold] blocking gaps. Orchestrating repair plan...")
+
+        # Load router
+        try:
+            config = load_config(Path("."))
+            validate_model_provider(config.models.provider)
+            api_key = get_api_key(config.models.provider, Path("."))
+        except (FileNotFoundError, ValueError) as e:
+            console.print(f"[red]{e}[/red]")
+            return
+        
+        provider = create_provider(config.models.provider, api_key)
+        role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
+        router = ModelRouter(provider, role_config)
+        repair_service = RepairService(router)
+        context_builder = ContextBuilder(Path("."))
+        
+        # Build minimal context for repair.
+        project_context = context_builder.get_structure_summary()
+
+        repair_output = await repair_service.generate_repair_plan(blocking_gaps, str(project_context))
+        
+        for task in repair_output.suggested_tasks:
+            task.id = f"REPAIR-{task.id}"
+            task_repo.save(task)
+            console.print(f"  - Created intelligent repair task [bold]{task.id}[/bold]: {task.title}")
+
+        console.print(f"\n[green]Successfully generated {len(repair_output.suggested_tasks)} repair tasks.[/green]")
+
+@app.callback(invoke_without_command=True)
+def repair(ctx: typer.Context):
+    """
+    Convert blocking gaps into intelligent repair tasks using LLM inference.
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    asyncio.run(run_repair_flow())

package/src/devcouncil/cli/commands/report.py

@@ -1,71 +1,129 @@
-import typer
-from rich.console import Console
-from rich.markdown import Markdown
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import ArtifactGraphRepository
-from devcouncil.reporting.report_builder import ReportBuilder
-from devcouncil.integrations.github import GitHubIntegration
+import typer
+from rich.console import Console
+from rich.markdown import Markdown
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import ArtifactGraphRepository
+from devcouncil.reporting.report_builder import ReportBuilder
+from devcouncil.integrations.github import GitHubIntegration
+from devcouncil.integrations.pr_comments import GitHubPRCommenter, GitLabMRCommenter, build_pr_comment_body
 from devcouncil.artifacts.graph import ArtifactGraph
 from devcouncil.telemetry.traces import TraceLogger
+from devcouncil.cli.commands.init import initialize_project
+from devcouncil.live.summary import live_review_summary
 import asyncio
 import os
 import subprocess
 from pathlib import Path
-
-app = typer.Typer()
-console = Console()
-
-async def run_github_report(graph: ArtifactGraph):
-    token = os.environ.get("GITHUB_TOKEN")
-    repo = os.environ.get("GITHUB_REPOSITORY") # e.g. owner/repo
-    
-    if not token or not repo:
-        console.print("[red]GITHUB_TOKEN and GITHUB_REPOSITORY must be set for GitHub reporting.[/red]")
-        return
-
-    try:
-        # Detect current SHA
-        sha = subprocess.check_output(["git", "rev-parse", "HEAD"]).decode().strip()
-        integration = GitHubIntegration(token, repo, sha)
-        await integration.report_verification(graph)
-        console.print(f"[green]Successfully reported to GitHub PR Checks for {repo} at {sha[:7]}[/green]")
-    except Exception as e:
-        console.print(f"[red]Failed to report to GitHub: {e}[/red]")
-
-@app.callback(invoke_without_command=True)
-def report(
-    ctx: typer.Context,
-    planning_only: bool = typer.Option(False, "--planning-only", help="Report only the planning phase status"),
-    json_format: bool = typer.Option(False, "--json", help="Output report in JSON format"),
-    github: bool = typer.Option(False, "--github", help="Post report to GitHub PR Checks"),
-):
-    """
-    Produce final evidence report.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    db = get_db()
-    if not db:
-        console.print("[red]DevCouncil not initialized. Run 'dev init' first.[/red]")
-        raise typer.Exit(code=1)
-
-    with db.get_session() as session:
+
+app = typer.Typer()
+console = Console()
+
+async def run_github_report(graph: ArtifactGraph, project_root: Path):
+    token = os.environ.get("GITHUB_TOKEN")
+    repo = os.environ.get("GITHUB_REPOSITORY") # e.g. owner/repo
+    
+    if not token or not repo:
+        console.print("[red]GITHUB_TOKEN and GITHUB_REPOSITORY must be set for GitHub reporting.[/red]")
+        return
+
+    try:
+        # Detect current SHA
+        sha = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=project_root).decode().strip()
+        integration = GitHubIntegration(token, repo, sha)
+        await integration.report_verification(graph)
+        console.print(f"[green]Successfully reported to GitHub PR Checks for {repo} at {sha[:7]}[/green]")
+    except Exception as e:
+        console.print(f"[red]Failed to report to GitHub: {e}[/red]")
+
+
+async def run_github_pr_comment(graph: ArtifactGraph, live_review: dict | None = None):
+    token = os.environ.get("GITHUB_TOKEN")
+    repo = os.environ.get("GITHUB_REPOSITORY")
+    pull_number = os.environ.get("GITHUB_PR_NUMBER") or os.environ.get("PR_NUMBER")
+    if not token or not repo or not pull_number:
+        console.print("[red]GITHUB_TOKEN, GITHUB_REPOSITORY, and GITHUB_PR_NUMBER must be set for GitHub PR comments.[/red]")
+        return
+    try:
+        pull_number_int = int(pull_number)
+    except ValueError:
+        console.print("[red]GITHUB_PR_NUMBER must be an integer.[/red]")
+        return
+    commenter = GitHubPRCommenter(token, repo, pull_number_int)
+    await commenter.post_comment(build_pr_comment_body(graph, live_review=live_review))
+    console.print(f"[green]Posted DevCouncil PR comment to GitHub PR #{pull_number}.[/green]")
+
+
+async def run_gitlab_mr_comment(graph: ArtifactGraph, live_review: dict | None = None):
+    token = os.environ.get("GITLAB_TOKEN")
+    project_id = os.environ.get("GITLAB_PROJECT_ID")
+    mr_iid = os.environ.get("GITLAB_MR_IID") or os.environ.get("CI_MERGE_REQUEST_IID")
+    base_url = os.environ.get("GITLAB_API_URL", "https://gitlab.com/api/v4")
+    if not token or not project_id or not mr_iid:
+        console.print("[red]GITLAB_TOKEN, GITLAB_PROJECT_ID, and GITLAB_MR_IID must be set for GitLab MR comments.[/red]")
+        return
+    try:
+        mr_iid_int = int(mr_iid)
+    except ValueError:
+        console.print("[red]GITLAB_MR_IID must be an integer.[/red]")
+        return
+    commenter = GitLabMRCommenter(token, project_id, mr_iid_int, base_url=base_url)
+    await commenter.post_comment(build_pr_comment_body(graph, live_review=live_review))
+    console.print(f"[green]Posted DevCouncil MR comment to GitLab MR !{mr_iid}.[/green]")
+
+@app.callback(invoke_without_command=True)
+def report(
+    ctx: typer.Context,
+    planning_only: bool = typer.Option(False, "--planning-only", help="Report only the planning phase status"),
+    json_format: bool = typer.Option(False, "--json", help="Output report in JSON format"),
+    github: bool = typer.Option(False, "--github", help="Post report to GitHub PR Checks"),
+    github_pr_comment: bool = typer.Option(False, "--github-pr-comment", help="Post report as a GitHub PR comment"),
+    gitlab_pr_comment: bool = typer.Option(False, "--gitlab-pr-comment", help="Post report as a GitLab merge request comment"),
+    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """
+    Produce final evidence report.
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    root = project_root.expanduser().resolve()
+    initialize_project(root, quiet=True)
+    db = get_db(root)
+    if not db:
+        console.print("[red]DevCouncil state is unavailable in this directory.[/red]")
+        raise typer.Exit(code=1)
+
+    with db.get_session() as session:
         graph_repo = ArtifactGraphRepository(session)
         graph = graph_repo.load_graph()
-        TraceLogger(Path(".")).log_event(
+        live_review = live_review_summary(root)
+        TraceLogger(root).log_event(
             "report_generated",
-            {"json": json_format, "github": github, "planning_only": planning_only},
+            {
+                "json": json_format,
+                "github": github,
+                "github_pr_comment": github_pr_comment,
+                "gitlab_pr_comment": gitlab_pr_comment,
+                "planning_only": planning_only,
+            },
             summary="Generated DevCouncil report",
         )
         
         if github:
-            asyncio.run(run_github_report(graph))
-            return
-
+            asyncio.run(run_github_report(graph, root))
+            return
+
+        if github_pr_comment:
+            asyncio.run(run_github_pr_comment(graph, live_review=live_review))
+            return
+
+        if gitlab_pr_comment:
+            asyncio.run(run_gitlab_mr_comment(graph, live_review=live_review))
+            return
+
         if json_format:
-            output = ReportBuilder.build_json(graph)
+            output = ReportBuilder.build_json(graph, live_review=live_review)
             typer.echo(output)
         else:
-            output = ReportBuilder.build_markdown(graph)
+            output = ReportBuilder.build_markdown(graph, live_review=live_review)
             console.print(Markdown(output))

package/src/devcouncil/cli/commands/reset_demo_state.py

@@ -1,28 +1,31 @@
-import typer
-from rich.console import Console
-from sqlmodel import delete
-
-from devcouncil.storage.db import get_db
-from devcouncil.storage.models import EvidenceModel, GapModel, RequirementModel, TaskModel
-
-console = Console()
-
-
-def reset_demo_state(
-    yes: bool = typer.Option(False, "--yes", help="Confirm clearing planning/demo artifacts."),
-):
-    """Clear demo planning artifacts from the local DevCouncil state database."""
-    if not yes:
-        console.print("[red]Refusing to clear state without --yes.[/red]")
-        raise typer.Exit(code=1)
-
-    db = get_db()
-    if not db:
-        console.print("[red]DevCouncil not initialized. Run 'dev init' first.[/red]")
-        raise typer.Exit(code=1)
-
-    with db.get_session() as session:
-        for model in (EvidenceModel, GapModel, TaskModel, RequirementModel):
-            session.exec(delete(model))
-
-    console.print("[green]Cleared requirements, tasks, gaps, and evidence from local state.[/green]")
+import typer
+from rich.console import Console
+from sqlmodel import delete
+from pathlib import Path
+
+from devcouncil.storage.db import get_db
+from devcouncil.storage.models import EvidenceModel, GapModel, RequirementModel, TaskModel
+from devcouncil.cli.commands.init import initialize_project
+
+console = Console()
+
+
+def reset_demo_state(
+    yes: bool = typer.Option(False, "--yes", help="Confirm clearing planning/demo artifacts."),
+):
+    """Clear demo planning artifacts from the local DevCouncil state database."""
+    if not yes:
+        console.print("[red]Refusing to clear state without --yes.[/red]")
+        raise typer.Exit(code=1)
+
+    initialize_project(Path("."), quiet=True)
+    db = get_db()
+    if not db:
+        console.print("[red]DevCouncil state is unavailable in this directory.[/red]")
+        raise typer.Exit(code=1)
+
+    with db.get_session() as session:
+        for model in (EvidenceModel, GapModel, TaskModel, RequirementModel):
+            session.exec(delete(model))
+
+    console.print("[green]Cleared requirements, tasks, gaps, and evidence from local state.[/green]")

package/src/devcouncil/cli/commands/rollback.py

@@ -1,24 +1,26 @@
-import typer
-import subprocess
-from pathlib import Path
-from rich.console import Console
-
-app = typer.Typer()
-console = Console()
-
-@app.callback(invoke_without_command=True)
-def rollback(
-    ctx: typer.Context,
-    task_id: str = typer.Argument(..., help="ID of the task to rollback"),
-):
-    """
-    Revert changes using a task's git checkpoint.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    checkpoint_file = Path(".devcouncil/checkpoints") / f"{task_id}-before.patch"
-    after_patch = Path(".devcouncil/checkpoints") / f"{task_id}-after.patch"
+import typer
+import subprocess
+from pathlib import Path
+from rich.console import Console
+
+app = typer.Typer()
+console = Console()
+
+@app.callback(invoke_without_command=True)
+def rollback(
+    ctx: typer.Context,
+    task_id: str = typer.Argument(..., help="ID of the task to rollback"),
+    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """
+    Revert changes using a task's git checkpoint.
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    root = project_root.expanduser().resolve()
+    checkpoint_file = root / ".devcouncil" / "checkpoints" / f"{task_id}-before.patch"
+    after_patch = root / ".devcouncil" / "checkpoints" / f"{task_id}-after.patch"
 
     if not checkpoint_file.exists() and not after_patch.exists():
         console.print(
@@ -28,31 +30,31 @@ def rollback(
         raise typer.Exit(code=1)
 
     console.print(f"Rolling back task [bold]{task_id}[/bold]...")
-    
-    try:
+    
+    try:
         if after_patch.exists():
             # Reverse-apply the task's changes only
-            console.print(f"Applying reverse patch from [bold]{after_patch}[/bold]...")
-            subprocess.check_call(
-                ["git", "apply", "-R", str(after_patch)],
-                cwd=".",
-            )
-            console.print(f"[green]Successfully rolled back task {task_id} changes.[/green]")
-        else:
-            # No after-patch, but we have the before-patch — warn and offer manual reset
-            console.print(
-                f"[yellow]No after-patch found at {after_patch}.[/yellow]\n"
-                f"The before-patch at {checkpoint_file} captured the state before the task ran.\n"
-                f"To manually reset:\n"
-                f"  1. [bold]git stash[/bold] (if you want to keep current changes)\n"
-                f"  2. [bold]git checkout -- .[/bold] (discard working tree changes)\n"
-                f"  3. [bold]git apply {checkpoint_file}[/bold] (restore pre-task state)"
-            )
-    except subprocess.CalledProcessError as e:
-        console.print(f"[red]Failed to apply reverse patch: {e}[/red]")
-        console.print("[yellow]The patch may conflict with current changes. Try resolving manually:[/yellow]")
-        console.print(f"  git apply -R --3way {after_patch}")
-        raise typer.Exit(code=1)
-    except Exception as e:
-        console.print(f"[red]Failed to rollback: {e}[/red]")
-        raise typer.Exit(code=1)
+            console.print(f"Applying reverse patch from [bold]{after_patch}[/bold]...")
+            subprocess.check_call(
+                ["git", "apply", "-R", str(after_patch)],
+                cwd=root,
+            )
+            console.print(f"[green]Successfully rolled back task {task_id} changes.[/green]")
+        else:
+            # No after-patch, but we have the before-patch — warn and offer manual reset
+            console.print(
+                f"[yellow]No after-patch found at {after_patch}.[/yellow]\n"
+                f"The before-patch at {checkpoint_file} captured the state before the task ran.\n"
+                f"To manually reset:\n"
+                f"  1. [bold]git stash[/bold] (if you want to keep current changes)\n"
+                f"  2. [bold]git checkout -- .[/bold] (discard working tree changes)\n"
+                f"  3. [bold]git apply {checkpoint_file}[/bold] (restore pre-task state)"
+            )
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]Failed to apply reverse patch: {e}[/red]")
+        console.print("[yellow]The patch may conflict with current changes. Try resolving manually:[/yellow]")
+        console.print(f"  git apply -R --3way {after_patch}")
+        raise typer.Exit(code=1)
+    except Exception as e:
+        console.print(f"[red]Failed to rollback: {e}[/red]")
+        raise typer.Exit(code=1)