devcouncil 0.1.0

package/src/devcouncil/artifacts/graph.py

@@ -0,0 +1,143 @@
+"""Artifact graph: the persistent, directed graph that links requirements to evidence.
+
+This is DevCouncil's core data structure:
+  Requirement -> AcceptanceCriterion -> Task -> PlannedFile -> ChangedFile
+              -> CommandResult -> TestEvidence -> Gap
+
+The graph enables coverage queries like:
+  - Which requirements have no tasks?
+  - Which tasks produced no changed files?
+  - Which acceptance criteria have no evidence?
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Set, Tuple
+
+from devcouncil.domain.requirement import Requirement, AcceptanceCriterion
+from devcouncil.domain.task import Task
+from devcouncil.domain.assumption import Assumption
+from devcouncil.domain.evidence import CommandResult, DiffEvidence, TestEvidence
+from devcouncil.domain.gap import Gap
+from devcouncil.domain.critique import CritiqueFinding
+
+
+@dataclass
+class ArtifactGraph:
+    """Directed graph of all planning and execution artifacts."""
+
+    requirements: Dict[str, Requirement] = field(default_factory=dict)
+    tasks: Dict[str, Task] = field(default_factory=dict)
+    assumptions: Dict[str, Assumption] = field(default_factory=dict)
+    findings: Dict[str, CritiqueFinding] = field(default_factory=dict)
+    gaps: Dict[str, Gap] = field(default_factory=dict)
+    test_evidence: List[TestEvidence] = field(default_factory=list)
+    diff_evidence: List[DiffEvidence] = field(default_factory=list)
+    command_results: List[CommandResult] = field(default_factory=list)
+
+    # --- Mutation ---
+
+    def add_requirement(self, req: Requirement) -> None:
+        self.requirements[req.id] = req
+
+    def add_task(self, task: Task) -> None:
+        self.tasks[task.id] = task
+
+    def add_assumption(self, asm: Assumption) -> None:
+        self.assumptions[asm.id] = asm
+
+    def add_finding(self, finding: CritiqueFinding) -> None:
+        self.findings[finding.id] = finding
+
+    def add_gap(self, gap: Gap) -> None:
+        self.gaps[gap.id] = gap
+
+    def add_test_evidence(self, ev: TestEvidence) -> None:
+        self.test_evidence.append(ev)
+
+    def add_diff_evidence(self, ev: DiffEvidence) -> None:
+        self.diff_evidence.append(ev)
+
+    def add_command_result(self, cr: CommandResult) -> None:
+        self.command_results.append(cr)
+
+    # --- Coverage Queries ---
+
+    def requirements_without_tasks(self) -> List[Requirement]:
+        """Requirements that are not mapped to any task."""
+        task_req_ids: Set[str] = set()
+        for task in self.tasks.values():
+            task_req_ids.update(task.requirement_ids)
+        return [r for r in self.requirements.values() if r.id not in task_req_ids]
+
+    def tasks_without_requirements(self) -> List[Task]:
+        """Tasks that don't map back to any requirement."""
+        return [t for t in self.tasks.values() if not t.requirement_ids]
+
+    def requirements_without_acceptance_criteria(self) -> List[Requirement]:
+        """Requirements with no acceptance criteria defined."""
+        return [r for r in self.requirements.values() if not r.acceptance_criteria]
+
+    def acceptance_criteria_without_evidence(self) -> List[Tuple[str, AcceptanceCriterion]]:
+        """AC IDs that have no test evidence mapped to them."""
+        evidenced_ac_ids: Set[str] = set()
+        for ev in self.test_evidence:
+            evidenced_ac_ids.add(ev.acceptance_criterion_id)
+
+        results: List[Tuple[str, AcceptanceCriterion]] = []
+        for req in self.requirements.values():
+            for ac in req.acceptance_criteria:
+                if ac.id not in evidenced_ac_ids:
+                    results.append((req.id, ac))
+        return results
+
+    def tasks_without_changed_files(self) -> List[Task]:
+        """Tasks that have not produced any diff evidence."""
+        tasks_with_diffs: Set[str] = set()
+        for de in self.diff_evidence:
+            tasks_with_diffs.add(de.task_id)
+        return [
+            t for t in self.tasks.values()
+            if t.id not in tasks_with_diffs and t.status not in ("planned", "ready")
+        ]
+
+    def open_findings(self, min_severity: str = "low") -> List[CritiqueFinding]:
+        """Critique findings that are still open."""
+        severity_order = {"low": 0, "medium": 1, "high": 2, "critical": 3}
+        min_rank = severity_order.get(min_severity, 0)
+        return [
+            f for f in self.findings.values()
+            if f.status == "open" and severity_order.get(f.severity, 0) >= min_rank
+        ]
+
+    def blocking_gaps(self) -> List[Gap]:
+        """Gaps that are blocking progress."""
+        return [g for g in self.gaps.values() if g.blocking]
+
+    def unconfirmed_high_impact_assumptions(self) -> List[Assumption]:
+        """Assumptions with high impact that are still open."""
+        return [
+            a for a in self.assumptions.values()
+            if a.status == "open" and a.impact == "high"
+        ]
+
+    # --- Aggregate ---
+
+    def coverage_summary(self) -> Dict[str, Any]:
+        """Produce a coverage summary for reporting."""
+        return {
+            "total_requirements": len(self.requirements),
+            "requirements_without_tasks": len(self.requirements_without_tasks()),
+            "requirements_without_ac": len(self.requirements_without_acceptance_criteria()),
+            "total_tasks": len(self.tasks),
+            "tasks_without_requirements": len(self.tasks_without_requirements()),
+            "tasks_without_diffs": len(self.tasks_without_changed_files()),
+            "total_ac": sum(len(r.acceptance_criteria) for r in self.requirements.values()),
+            "ac_without_evidence": len(self.acceptance_criteria_without_evidence()),
+            "total_gaps": len(self.gaps),
+            "blocking_gaps": len(self.blocking_gaps()),
+            "open_findings": len(self.open_findings()),
+            "high_critical_open_findings": len(self.open_findings("high")),
+            "unconfirmed_high_assumptions": len(self.unconfirmed_high_impact_assumptions()),
+        }

package/src/devcouncil/artifacts/migrations.py

@@ -0,0 +1,20 @@
+from typing import Any, Dict
+
+class ArtifactMigrator:
+    """Migrates artifact schemas across DevCouncil versions."""
+    
+    @staticmethod
+    def migrate_requirement(data: Dict[str, Any]) -> Dict[str, Any]:
+        """Upgrade requirement payload to current schema."""
+        if "priority" not in data:
+            data["priority"] = "medium"
+        return data
+
+    @staticmethod
+    def migrate_task(data: Dict[str, Any]) -> Dict[str, Any]:
+        """Upgrade task payload to current schema."""
+        if "forbidden_changes" not in data:
+            data["forbidden_changes"] = []
+        if "expected_tests" not in data:
+            data["expected_tests"] = []
+        return data

package/src/devcouncil/artifacts/schemas.py

@@ -0,0 +1,23 @@
+from typing import List
+from pydantic import BaseModel, Field
+
+# Common schemas that might be shared across artifacts
+class FileModification(BaseModel):
+    path: str
+    diff: str
+
+class CoverageMatrix(BaseModel):
+    """Represents a requirement to task/test mapping coverage."""
+    requirement_id: str
+    task_ids: List[str] = Field(default_factory=list)
+    test_evidence_ids: List[str] = Field(default_factory=list)
+    is_covered: bool = False
+    missing_tasks: bool = False
+    missing_tests: bool = False
+
+class ReportSchema(BaseModel):
+    project_id: str
+    tasks_completed: int
+    tasks_blocked: int
+    open_gaps: int
+    coverage_matrix: List[CoverageMatrix]

package/src/devcouncil/artifacts/serializer.py

@@ -0,0 +1,21 @@
+import json
+from typing import Any, Dict, TypeVar, Type
+from pydantic import BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+class ArtifactSerializer:
+    """Handles serialization and deserialization of DevCouncil artifacts."""
+    
+    @staticmethod
+    def to_json(artifact: BaseModel) -> str:
+        return artifact.model_dump_json(indent=2)
+
+    @staticmethod
+    def from_json(json_str: str, model_class: Type[T]) -> T:
+        data = json.loads(json_str)
+        return model_class.model_validate(data)
+
+    @staticmethod
+    def to_dict(artifact: BaseModel) -> Dict[str, Any]:
+        return artifact.model_dump()

package/src/devcouncil/artifacts/validators.py

@@ -0,0 +1,27 @@
+from devcouncil.domain.requirement import Requirement
+from devcouncil.domain.task import Task
+from devcouncil.app.errors import GatingError
+
+class ArtifactValidator:
+    """Validates DevCouncil artifacts (tasks, requirements, etc.)."""
+    
+    @staticmethod
+    def validate_requirement(req: Requirement) -> None:
+        if not req.title:
+            raise GatingError(f"Requirement {req.id} missing title.")
+        if not req.acceptance_criteria:
+            raise GatingError(f"Requirement {req.id} must have at least one acceptance criterion.")
+        for ac in req.acceptance_criteria:
+            if not ac.verification_method:
+                raise GatingError(f"Acceptance criterion {ac.id} in {req.id} missing verification method.")
+
+    @staticmethod
+    def validate_task(task: Task) -> None:
+        if not task.requirement_ids:
+            raise GatingError(f"Task {task.id} must map to at least one requirement.")
+        if not task.planned_files:
+            raise GatingError(f"Task {task.id} must have at least one planned file.")
+        if not task.acceptance_criterion_ids:
+            raise GatingError(f"Task {task.id} must map to at least one acceptance criterion.")
+        if not task.allowed_commands and not task.expected_tests:
+            raise GatingError(f"Task {task.id} must define allowed commands or expected tests.")

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

@@ -0,0 +1,48 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from devcouncil.app.errors import GatingError
+from devcouncil.artifacts.validators import ArtifactValidator
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import RequirementRepository, TaskRepository
+
+app = typer.Typer()
+console = Console()
+
+
+@app.command(name="validate")
+def validate():
+    """Validate requirements and tasks stored in the artifact graph."""
+    db = get_db()
+    if not db:
+        console.print("[red]DevCouncil not initialized. Run 'dev init' first.[/red]")
+        raise typer.Exit(code=1)
+
+    errors: list[str] = []
+    with db.get_session() as session:
+        req_repo = RequirementRepository(session)
+        task_repo = TaskRepository(session)
+
+        for req in req_repo.get_all():
+            try:
+                ArtifactValidator.validate_requirement(req)
+            except GatingError as exc:
+                errors.append(str(exc))
+
+        for task in task_repo.get_all():
+            try:
+                ArtifactValidator.validate_task(task)
+            except GatingError as exc:
+                errors.append(str(exc))
+
+    if not errors:
+        console.print("[green]Artifacts are valid.[/green]")
+        return
+
+    table = Table(title="Artifact Validation Errors")
+    table.add_column("Error", style="red")
+    for error in errors:
+        table.add_row(error)
+    console.print(table)
+    raise typer.Exit(code=1)

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

@@ -0,0 +1,32 @@
+import json
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from devcouncil.storage.db import get_db
+from devcouncil.verification.verifier import Verifier
+
+console = Console()
+
+
+def baseline(
+    force: bool = typer.Option(False, "--force", help="Overwrite an existing baseline snapshot."),
+):
+    """Capture the current repo state as DevCouncil's verification baseline."""
+    if not get_db():
+        console.print("[red]DevCouncil not initialized. Run 'dev init' first.[/red]")
+        raise typer.Exit(code=1)
+
+    baseline_path = Path(".devcouncil") / "baseline.json"
+    if baseline_path.exists() and not force:
+        console.print("[yellow]Baseline already exists. Use --force to replace it.[/yellow]")
+        raise typer.Exit(code=1)
+
+    changed_files = Verifier(Path(".")).get_changed_files()
+    payload = {
+        "changed_files": changed_files,
+        "note": "Files present in this snapshot are excluded from future task-scoped verification diffs.",
+    }
+    baseline_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    console.print(f"[green]Captured baseline with {len(changed_files)} changed file(s).[/green]")

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

@@ -0,0 +1,54 @@
+import typer
+import yaml
+from pathlib import Path
+from rich.console import Console
+from devcouncil.app.config import load_config
+
+app = typer.Typer(help="Manage DevCouncil configuration")
+console = Console()
+
+@app.command("models")
+def models(
+    role: str = typer.Option(None, "--role", "-r", help="Specific role to show/edit"),
+    model: str = typer.Option(None, "--model", "-m", help="New model string to set for the role")
+):
+    """View or edit model role configuration."""
+    try:
+        load_config(Path("."))
+    except FileNotFoundError as e:
+        console.print(f"[red]{e}[/red]")
+        return
+
+    config_path = Path(".devcouncil/config.yaml")
+    
+    with open(config_path) as f:
+        raw_config = yaml.safe_load(f) or {}
+
+    if not role:
+        console.print("[bold]Model Configuration[/bold]")
+        for r, m in raw_config.get("models", {}).get("roles", {}).items():
+            console.print(f"  [cyan]{r}[/cyan]: {m.get('model')}")
+        return
+
+    if not model:
+        m = raw_config.get("models", {}).get("roles", {}).get(role)
+        if m:
+            console.print(f"[cyan]{role}[/cyan]: {m.get('model')}")
+        else:
+            console.print(f"[red]Role '{role}' not found.[/red]")
+        return
+
+    if "models" not in raw_config:
+        raw_config["models"] = {"roles": {}}
+    if "roles" not in raw_config["models"]:
+        raw_config["models"]["roles"] = {}
+        
+    if role not in raw_config["models"]["roles"]:
+        raw_config["models"]["roles"][role] = {}
+        
+    raw_config["models"]["roles"][role]["model"] = model
+    
+    with open(config_path, "w") as f:
+        yaml.dump(raw_config, f, default_flow_style=False)
+        
+    console.print(f"[green]Updated '{role}' to use model '{model}'[/green]")

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

@@ -0,0 +1,96 @@
+import typer
+import subprocess
+import os
+import shutil
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+
+app = typer.Typer()
+console = Console()
+
+def render_doctor_check():
+    def _command_version(command: list[str]) -> str | None:
+        executable = shutil.which(command[0])
+        if not executable:
+            return None
+
+        resolved_command = [executable, *command[1:]]
+        use_shell = os.name == "nt" and Path(executable).suffix.lower() in {".bat", ".cmd", ".ps1"}
+        invocation = subprocess.list2cmdline(resolved_command) if use_shell else resolved_command
+        try:
+            return subprocess.check_output(
+                invocation,
+                stderr=subprocess.STDOUT,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                shell=use_shell,
+                timeout=10,
+            ).splitlines()[0].strip()
+        except Exception:
+            return None
+
+    table = Table(title="DevCouncil Doctor Check")
+    table.add_column("Component", style="cyan")
+    table.add_column("Status", style="magenta")
+    table.add_column("Notes", style="green")
+
+    # Check Git
+    git_ver = _command_version(["git", "--version"])
+    if git_ver:
+        table.add_row("Git", "[green]OK[/green]", git_ver)
+    else:
+        table.add_row("Git", "[red]Missing[/red]", "Git is required for repo mapping and checkpoints.")
+
+    # Check uv
+    uv_ver = _command_version(["uv", "--version"])
+    if uv_ver:
+        table.add_row("uv", "[green]OK[/green]", uv_ver)
+    else:
+        table.add_row("uv", "[red]Missing[/red]", "Install uv to run or install DevCouncil.")
+
+    # Check CLI shims
+    if shutil.which("devcouncil"):
+        table.add_row("devcouncil CLI", "[green]OK[/green]", "Found on PATH.")
+    else:
+        table.add_row("devcouncil CLI", "[yellow]Missing[/yellow]", "Run via 'uv run devcouncil' or install with 'uv tool install --force .'.")
+
+    # Check ripgrep
+    rg_ver = _command_version(["rg", "--version"])
+    if rg_ver:
+        table.add_row("ripgrep (rg)", "[green]OK[/green]", rg_ver)
+    else:
+        table.add_row("ripgrep (rg)", "[yellow]Missing[/yellow]", "ripgrep is highly recommended for fast repo mapping.")
+
+    # Check supported coding CLIs
+    codex_ver = _command_version(["codex", "--version"])
+    if codex_ver:
+        table.add_row("Codex CLI", "[green]OK[/green]", f"{codex_ver}. Setup: dev integrate codex --apply")
+    else:
+        table.add_row("Codex CLI", "[yellow]Missing[/yellow]", "Optional. Install Codex, then run 'dev integrate codex --apply'.")
+
+    gemini_ver = _command_version(["gemini", "--version"])
+    if gemini_ver:
+        table.add_row("Gemini CLI", "[green]OK[/green]", f"{gemini_ver}. Setup: dev integrate gemini --apply")
+    else:
+        table.add_row("Gemini CLI", "[yellow]Missing[/yellow]", "Optional. Install Gemini CLI, then run 'dev integrate gemini --apply'.")
+
+    # Check OpenRouter API Key
+    if os.environ.get("OPENROUTER_API_KEY"):
+        table.add_row("OPENROUTER_API_KEY", "[green]OK[/green]", "Found in environment.")
+    else:
+        table.add_row("OPENROUTER_API_KEY", "[yellow]Missing[/yellow]", "Required if using OpenRouter provider.")
+
+    console.print(table)
+
+
+@app.callback(invoke_without_command=True)
+def doctor(ctx: typer.Context):
+    """
+    Check the environment for DevCouncil prerequisites.
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    render_doctor_check()

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

@@ -0,0 +1,61 @@
+import typer
+import json
+import os
+import sys
+from pathlib import Path
+from rich.console import Console
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import TaskRepository
+from devcouncil.execution.hook_policy import HookPolicy
+
+app = typer.Typer()
+console = Console()
+
+
+def _project_root() -> Path:
+    configured = os.environ.get("DEVCOUNCIL_PROJECT_ROOT")
+    return Path(configured).expanduser().resolve() if configured else Path(".").resolve()
+
+@app.command()
+def pre_tool_use(
+    tool_call_json: str | None = typer.Argument(None, help="The JSON string of the tool call from Claude Code")
+):
+    """
+    Claude Code hook: Inspects a tool call before execution.
+    Exits with code 2 to block unauthorized file writes.
+    """
+    try:
+        if tool_call_json is None:
+            tool_call_json = sys.stdin.read()
+        if not tool_call_json.strip():
+            raise typer.Exit(code=0)
+        call_data = json.loads(tool_call_json)
+        active_task = None
+        root = _project_root()
+        db = get_db(root)
+        if db:
+            with db.get_session() as session:
+                task_repo = TaskRepository(session)
+                running_tasks = [t for t in task_repo.get_all() if t.status == "running"]
+                active_task = running_tasks[0] if running_tasks else None
+
+        decision = HookPolicy(project_root=root).evaluate(call_data, active_task)
+        if decision.action == "deny":
+            console.print(f"[red]DevCouncil Blocked Action:[/red] {decision.reason}")
+            sys.exit(2)
+        if decision.action == "warn":
+            console.print(f"[yellow]DevCouncil Warning:[/yellow] {decision.reason}")
+                
+    except json.JSONDecodeError:
+        raise typer.Exit(code=0)
+
+@app.command()
+def post_task():
+    """
+    Claude Code hook: Runs after a task is completed.
+    Triggers deterministic verification.
+    """
+    console.print("[cyan]DevCouncil: Claude finished task. Triggering automatic verification...[/cyan]")
+    # In a real environment, this would invoke 'dev verify <active-task>'
+    # For the hook script, we just notify the user.
+    console.print("Run [bold]dev verify[/bold] to finalize implementation evidence.")

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

@@ -0,0 +1,142 @@
+import copy
+import typer
+import yaml
+from rich.console import Console
+from pathlib import Path
+from devcouncil.storage.db import Database
+from devcouncil.integrations.gitnexus import GitNexusIntegration
+from devcouncil.integrations.graphify import GraphifyIntegration
+
+app = typer.Typer()
+console = Console()
+
+DEFAULT_CONFIG = {
+    "project": {
+        "name": "devcouncil-project",
+        "root": ".",
+        "default_branch": "main",
+    },
+    "models": {
+        "provider": "openrouter",
+        "roles": {
+            "spec_writer": {"model": "anthropic/claude-3.5-sonnet"},
+            "planner_a": {"model": "anthropic/claude-3.5-sonnet"},
+            "planner_b": {"model": "google/gemini-pro-1.5"},
+            "critic_a": {"model": "openai/gpt-4o"},
+            "critic_b": {"model": "anthropic/claude-3-opus"},
+            "arbiter": {"model": "openai/gpt-4o"},
+            "native_agent": {"model": "anthropic/claude-3.5-sonnet"},
+            "implementation_reviewer": {"model": "openai/gpt-4o"},
+        }
+    },
+    "commands": {
+        "test": ["pytest", "npm test"],
+        "lint": ["flake8", "eslint"],
+        "typecheck": ["mypy", "tsc"]
+    },
+    "gates": {
+        "require_clean_git_before_task": True,
+        "block_orphan_diffs": True,
+        "block_missing_tests_for_high_requirements": True,
+        "block_dependency_changes_without_approval": True,
+        "block_schema_change_without_migration": True,
+        "block_failed_commands": True
+    },
+    "execution": {
+        "default_executor": "native",
+        "max_repair_attempts": 3,
+        "checkpoint_before_each_task": True
+    },
+    "privacy": {
+        "redact_env_vars": True,
+        "redact_secrets_in_logs": True,
+        "store_prompts_locally": True
+    },
+    "integrations": {
+        "agent_flow": {
+            "enabled": False,
+            "trace_path": ".devcouncil/logs/traces.jsonl",
+            "mode": "jsonl",
+        },
+        "code_review_graph": {
+            "enabled": False,
+            "command": "code-review-graph",
+            "optional": True,
+        },
+    }
+}
+
+
+def initialize_project(
+    project_root: Path = Path("."),
+    project_name: str | None = None,
+    with_gitnexus: bool = False,
+    with_graphify: bool = False,
+) -> bool:
+    """Initialize DevCouncil project state.
+
+    Returns True when a fresh .devcouncil directory was created.
+    """
+    project_root = project_root.resolve()
+    dev_dir = project_root / ".devcouncil"
+    created = False
+
+    if not dev_dir.exists():
+        console.print("Initializing DevCouncil...")
+        dev_dir.mkdir(exist_ok=True)
+        (dev_dir / "runs").mkdir(exist_ok=True)
+        (dev_dir / "cache").mkdir(exist_ok=True)
+        (dev_dir / "checkpoints").mkdir(exist_ok=True)
+        (dev_dir / "logs").mkdir(exist_ok=True)
+
+        config_path = dev_dir / "config.yaml"
+        config = copy.deepcopy(DEFAULT_CONFIG)
+        if project_name:
+            config["project"]["name"] = project_name
+        else:
+            config["project"]["name"] = project_root.name
+
+        with open(config_path, "w") as f:
+            yaml.dump(config, f, default_flow_style=False)
+
+        db = Database(dev_dir / "state.sqlite")
+        db.create_db_and_tables()
+        console.print(f"[green]Successfully initialized DevCouncil in {dev_dir}[/green]")
+        created = True
+
+    if with_gitnexus:
+        nexus = GitNexusIntegration(project_root)
+        nexus.initialize()
+
+    if with_graphify:
+        graphify = GraphifyIntegration(project_root)
+        graphify.initialize()
+
+    return created
+
+
+@app.callback(invoke_without_command=True)
+def init(
+    ctx: typer.Context,
+    project_name: str = typer.Option(None, "--name", "-n", help="Project name"),
+    with_gitnexus: bool = typer.Option(False, "--gitnexus", help="Initialize GitNexus structural awareness"),
+    with_graphify: bool = typer.Option(False, "--graphify", help="Initialize Graphify knowledge graph engine"),
+):
+    """
+    Initialize DevCouncil in the current directory.
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    dev_dir = Path(".devcouncil")
+    if dev_dir.exists() and not (with_gitnexus or with_graphify):
+        console.print("[yellow]DevCouncil is already initialized in this directory.[/yellow]")
+        console.print("Use --gitnexus or --graphify to add upgrade paths.")
+        raise typer.Exit()
+
+    initialize_project(
+        Path("."),
+        project_name=project_name,
+        with_gitnexus=with_gitnexus,
+        with_graphify=with_graphify,
+    )