nexus-dev-toolkit 3.1.0__tar.gz → 3.1.2__tar.gz

{nexus_dev_toolkit-3.1.0/nexus_dev_toolkit.egg-info → nexus_dev_toolkit-3.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nexus-dev-toolkit
-Version: 3.1.0
+Version: 3.1.2
 Summary: Developer workflow toolkit for Claude Code — Day 0 scaffold + Day 1 EPAV
 Author-email: Ronald dela Cruz <rcdelacruz@users.noreply.github.com>
 License-Expression: MIT
@@ -80,7 +80,8 @@ uv tool install nexus-dev-toolkit
 
 ```bash
 cd my-project
-nexus init .
+nexus init .                    # Claude Code (default)
+nexus init . --tool opencode    # OpenCode
 ```
 
 ### 4. Place your reference docs
@@ -137,15 +138,11 @@ Each step is a built-in skill in `.claude/commands/`. Every task starts from the
 
 ## What `nexus init` Creates
 
+**Claude Code** (`nexus init .`):
 ```
 .claude/
-├── commands/
-│   ├── scaffold.md    ← /scaffold  — Day 0 one-time setup
-│   ├── evaluate.md    ← /evaluate  — orient on a task
-│   ├── plan.md        ← /plan      — blueprint, no code
-│   ├── apply.md       ← /apply     — implement the plan
-│   ├── validate.md    ← /validate  — verify acceptance criteria
-│   └── epav.md        ← /epav      — full cycle guide
+├── commands/          ← EPAV skills + 5 reviewer skills (/code-review, etc.)
+├── agents/            ← 5 reviewer subagents (code-reviewer, database-reviewer, etc.)
 └── settings.json      ← PostToolUse: graphify auto-updates after every file edit
 knowledge/
 ├── rules/             ← coding standards, arch decisions
@@ -155,17 +152,35 @@ knowledge/
 .mcp.json              ← MCP server config
 ```
 
+**OpenCode** (`nexus init . --tool opencode`):
+```
+.opencode/
+├── commands/          ← same EPAV skills + reviewer skills
+├── agents/            ← same reviewer subagents (adapted for OpenCode)
+└── plugins/
+    └── graphify.js    ← tool.execute.after: graphify auto-update
+knowledge/             ← same structure
+opencode.json          ← MCP server config
+```
+
 ---
 
 ## Commands
 
 ```bash
-nexus init .                 # set up .claude/commands/ + knowledge/ + .mcp.json
-nexus skill add code-review  # create a custom skill in .claude/commands/
-nexus skill list             # list all skills
-nexus rule add api-standards # create a rule in knowledge/rules/
-nexus rule list              # list all rules
-nexus update                 # update to latest version
+nexus init .                      # Claude Code — set up .claude/ + knowledge/ + .mcp.json
+nexus init . --tool opencode      # OpenCode — set up .opencode/ + knowledge/ + opencode.json
+nexus --version                   # show installed version
+nexus update                      # update to latest version
+
+nexus skill list                  # list all skills in .claude/commands/
+nexus skill add my-review         # create a custom skill
+
+nexus agent list                  # list all subagents in .claude/agents/
+nexus agent add my-agent          # create a custom subagent
+
+nexus rule list                   # list all rules in knowledge/rules/
+nexus rule add api-standards      # create a project rule
 ```
 
 ---

{nexus_dev_toolkit-3.1.0 → nexus_dev_toolkit-3.1.2}/README.md

@@ -59,7 +59,8 @@ uv tool install nexus-dev-toolkit
 
 ```bash
 cd my-project
-nexus init .
+nexus init .                    # Claude Code (default)
+nexus init . --tool opencode    # OpenCode
 ```
 
 ### 4. Place your reference docs
@@ -116,15 +117,11 @@ Each step is a built-in skill in `.claude/commands/`. Every task starts from the
 
 ## What `nexus init` Creates
 
+**Claude Code** (`nexus init .`):
 ```
 .claude/
-├── commands/
-│   ├── scaffold.md    ← /scaffold  — Day 0 one-time setup
-│   ├── evaluate.md    ← /evaluate  — orient on a task
-│   ├── plan.md        ← /plan      — blueprint, no code
-│   ├── apply.md       ← /apply     — implement the plan
-│   ├── validate.md    ← /validate  — verify acceptance criteria
-│   └── epav.md        ← /epav      — full cycle guide
+├── commands/          ← EPAV skills + 5 reviewer skills (/code-review, etc.)
+├── agents/            ← 5 reviewer subagents (code-reviewer, database-reviewer, etc.)
 └── settings.json      ← PostToolUse: graphify auto-updates after every file edit
 knowledge/
 ├── rules/             ← coding standards, arch decisions
@@ -134,17 +131,35 @@ knowledge/
 .mcp.json              ← MCP server config
 ```
 
+**OpenCode** (`nexus init . --tool opencode`):
+```
+.opencode/
+├── commands/          ← same EPAV skills + reviewer skills
+├── agents/            ← same reviewer subagents (adapted for OpenCode)
+└── plugins/
+    └── graphify.js    ← tool.execute.after: graphify auto-update
+knowledge/             ← same structure
+opencode.json          ← MCP server config
+```
+
 ---
 
 ## Commands
 
 ```bash
-nexus init .                 # set up .claude/commands/ + knowledge/ + .mcp.json
-nexus skill add code-review  # create a custom skill in .claude/commands/
-nexus skill list             # list all skills
-nexus rule add api-standards # create a rule in knowledge/rules/
-nexus rule list              # list all rules
-nexus update                 # update to latest version
+nexus init .                      # Claude Code — set up .claude/ + knowledge/ + .mcp.json
+nexus init . --tool opencode      # OpenCode — set up .opencode/ + knowledge/ + opencode.json
+nexus --version                   # show installed version
+nexus update                      # update to latest version
+
+nexus skill list                  # list all skills in .claude/commands/
+nexus skill add my-review         # create a custom skill
+
+nexus agent list                  # list all subagents in .claude/agents/
+nexus agent add my-agent          # create a custom subagent
+
+nexus rule list                   # list all rules in knowledge/rules/
+nexus rule add api-standards      # create a project rule
 ```
 
 ---

{nexus_dev_toolkit-3.1.0 → nexus_dev_toolkit-3.1.2}/nexus_cli.py

@@ -11,12 +11,14 @@ from rich.table import Table
 app = typer.Typer(name="nexus", no_args_is_help=False, help="nexus-dev-toolkit — Day 0 scaffold + Day 1 EPAV workflow for Claude Code")
 skill_app = typer.Typer(name="skill", no_args_is_help=True, help="Manage skills in .claude/commands/")
 rule_app = typer.Typer(name="rule", no_args_is_help=True, help="Manage rules in knowledge/rules/")
+agent_app = typer.Typer(name="agent", no_args_is_help=True, help="Manage subagents in .claude/agents/")
 app.add_typer(skill_app, name="skill")
 app.add_typer(rule_app, name="rule")
+app.add_typer(agent_app, name="agent")
 
 console = Console()
 
-_VERSION = "3.1.0"
+_VERSION = "3.1.2"
 
 _LOGO = """\
 [cyan]███╗   ██╗███████╗██╗  ██╗██╗   ██╗███████╗[/cyan]
@@ -35,8 +37,17 @@ def _print_logo() -> None:
     console.print()
 
 
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"nexus-dev-toolkit v{_VERSION}")
+        raise typer.Exit()
+
+
 @app.callback(invoke_without_command=True)
-def _callback(ctx: typer.Context) -> None:
+def _callback(
+    ctx: typer.Context,
+    version: bool = typer.Option(None, "--version", "-V", callback=_version_callback, is_eager=True, help="Show version and exit."),
+) -> None:
     if ctx.invoked_subcommand is None:
         _print_logo()
         console.print(ctx.get_help())
@@ -106,6 +117,29 @@ _MCP_BLOCK = {
     }
 }
 
+_OPENCODE_MCP_BLOCK = {
+    "nexus-mcp": {
+        "type": "local",
+        "command": ["uvx", "--refresh", "--from", "nexus-dev-toolkit", "nexus-mcp"],
+    }
+}
+
+_OPENCODE_GRAPHIFY_PLUGIN = """\
+// .opencode/plugins/graphify.js
+// Auto-updates the graphify knowledge graph after every tool execution.
+import { execSync } from "node:child_process"
+
+export const GraphifyPlugin = async ({ directory }) => {
+  return {
+    "tool.execute.after": async () => {
+      try {
+        execSync("graphify update . --force", { cwd: directory, stdio: "ignore" })
+      } catch (_) {}
+    },
+  }
+}
+"""
+
 
 def _init_project(project_dir: Path) -> list[str]:
     """
@@ -153,6 +187,81 @@ def _init_project(project_dir: Path) -> list[str]:
     return created
 
 
+def _strip_claude_frontmatter(content: str) -> str:
+    """Remove Claude Code-only frontmatter fields (tools, model) for OpenCode compatibility."""
+    if not content.startswith("---"):
+        return content
+    parts = content.split("---", 2)
+    if len(parts) < 3:
+        return content
+    lines = [
+        line for line in parts[1].splitlines()
+        if not line.startswith("tools:") and not line.startswith("model:")
+    ]
+    return "---" + "\n".join(lines) + "---" + parts[2]
+
+
+def _init_opencode(project_dir: Path) -> list[str]:
+    """
+    nexus init --tool opencode — sets up:
+      .opencode/commands/   ← built-in skills
+      .opencode/agents/     ← built-in subagents
+      .opencode/plugins/    ← graphify PostToolUse hook
+      opencode.json         ← MCP server config
+      knowledge/            ← empty scaffold
+    """
+    created = []
+
+    # .opencode/commands/ — copy built-in skills
+    commands_dir = project_dir / ".opencode" / "commands"
+    commands_dir.mkdir(parents=True, exist_ok=True)
+    for skill_name in _BUILTIN_SKILLS:
+        src = _SKILLS_SRC / skill_name
+        dest = commands_dir / skill_name
+        if src.exists() and not dest.exists():
+            shutil.copy2(src, dest)
+            created.append(f".opencode/commands/{skill_name}")
+
+    # .opencode/agents/ — copy built-in subagents, stripping Claude Code-only frontmatter
+    agents_dir = project_dir / ".opencode" / "agents"
+    agents_dir.mkdir(parents=True, exist_ok=True)
+    for agent_name in _BUILTIN_AGENTS:
+        src = _AGENTS_SRC / agent_name
+        dest = agents_dir / agent_name
+        if src.exists() and not dest.exists():
+            dest.write_text(_strip_claude_frontmatter(src.read_text()), encoding="utf-8")
+            created.append(f".opencode/agents/{agent_name}")
+
+    # .opencode/plugins/graphify.js — PostToolUse hook
+    plugins_dir = project_dir / ".opencode" / "plugins"
+    plugins_dir.mkdir(parents=True, exist_ok=True)
+    plugin_path = plugins_dir / "graphify.js"
+    if not plugin_path.exists():
+        plugin_path.write_text(_OPENCODE_GRAPHIFY_PLUGIN, encoding="utf-8")
+        created.append(".opencode/plugins/graphify.js")
+
+    # opencode.json — MCP server config
+    opencode_json = project_dir / "opencode.json"
+    existing: dict = {}
+    if opencode_json.exists():
+        try:
+            existing = json.loads(opencode_json.read_text())
+        except Exception:
+            pass
+    already_has_mcp = "nexus-mcp" in existing.get("mcp", {})
+    existing.setdefault("$schema", "https://opencode.ai/config.json")
+    existing.setdefault("mcp", {}).update(_OPENCODE_MCP_BLOCK)
+    opencode_json.write_text(json.dumps(existing, indent=2))
+    if not already_has_mcp:
+        created.append("opencode.json")
+
+    # knowledge/ scaffold
+    for d in _KNOWLEDGE_DIRS:
+        (project_dir / d).mkdir(parents=True, exist_ok=True)
+
+    return created
+
+
 def _write_mcp_config(project_dir: Path) -> str:
     mcp_path = project_dir / ".mcp.json"
     existing: dict = {}
@@ -168,26 +277,80 @@ def _write_mcp_config(project_dir: Path) -> str:
 
 # ── Commands ──────────────────────────────────────────────────────────────────
 
+_SUPPORTED_TOOLS = ["claude", "opencode"]
+
+_TOOL_CHECK = {
+    "claude": {
+        "bin": "claude",
+        "name": "Claude Code",
+        "install": "npm install -g @anthropic-ai/claude-code && claude login",
+        "install_cmd": ["npm", "install", "-g", "@anthropic-ai/claude-code"],
+    },
+    "opencode": {
+        "bin": "opencode",
+        "name": "OpenCode",
+        "install": "curl -fsSL https://opencode.ai/install | bash",
+        "install_cmd": None,  # pipe install — run via shell
+    },
+}
+
+
+def _check_and_offer_install(tool: str) -> None:
+    info = _TOOL_CHECK[tool]
+    if shutil.which(info["bin"]):
+        return
+
+    console.print(f"  [yellow]⚠[/yellow]  {info['name']} not found — you need it to use nexus.\n")
+    answer = console.input(f"  Install {info['name']} now? [y/N] ").strip().lower()
+    if answer != "y":
+        console.print(f"  [dim]Skipping. Install manually: {info['install']}[/dim]\n")
+        return
+
+    console.print(f"  [cyan]▶[/cyan]  Installing {info['name']}…\n")
+    if info["install_cmd"]:
+        result = subprocess.run(info["install_cmd"])
+    else:
+        result = subprocess.run(info["install"], shell=True)
+
+    if result.returncode == 0:
+        console.print(f"  [green]✓[/green]  {info['name']} installed.\n")
+    else:
+        console.print(f"  [red]✗[/red]  Install failed. Run manually: {info['install']}\n")
+
+
 @app.command()
 def init(
     project_dir: str = typer.Argument(".", help="Project directory to initialize"),
+    tool: str = typer.Option("claude", "--tool", "-t", help=f"AI coding tool to set up for ({', '.join(_SUPPORTED_TOOLS)})"),
 ) -> None:
-    """Initialize .claude/commands/, .claude/settings.json, and knowledge/ in a project."""
-    root = Path(project_dir).resolve()
-    console.print(f"  [cyan]▶[/cyan]  Initializing nexus in [bold]{root}[/bold]\n")
+    """Initialize nexus in a project directory. Defaults to Claude Code."""
+    if tool not in _SUPPORTED_TOOLS:
+        console.print(f"  [red]✗[/red]  Unknown tool '{tool}'. Supported: {', '.join(_SUPPORTED_TOOLS)}")
+        raise typer.Exit(1)
 
-    created = _init_project(root)
-    for f in created:
-        console.print(f"  [green]✓[/green]  {f}")
-
-    if not created:
-        console.print("  [yellow]·[/yellow]  Already initialized — nothing to do")
-        return
+    _check_and_offer_install(tool)
 
-    mcp = _write_mcp_config(root)
-    console.print(f"  [green]✓[/green]  {mcp}")
-
-    console.print(f"\n  [bold green]Done.[/bold green] Open [bold]{root}[/bold] in Claude Code and type [cyan]/scaffold[/cyan]\n")
+    root = Path(project_dir).resolve()
+    console.print(f"  [cyan]▶[/cyan]  Initializing nexus for [bold]{tool}[/bold] in [bold]{root}[/bold]\n")
+
+    if tool == "opencode":
+        created = _init_opencode(root)
+        for f in created:
+            console.print(f"  [green]✓[/green]  {f}")
+        if not created:
+            console.print("  [yellow]·[/yellow]  Already initialized — nothing to do")
+            return
+        console.print(f"\n  [bold green]Done.[/bold green] Open [bold]{root}[/bold] in OpenCode and type [cyan]/scaffold[/cyan]\n")
+    else:
+        created = _init_project(root)
+        for f in created:
+            console.print(f"  [green]✓[/green]  {f}")
+        if not created:
+            console.print("  [yellow]·[/yellow]  Already initialized — nothing to do")
+            return
+        mcp = _write_mcp_config(root)
+        console.print(f"  [green]✓[/green]  {mcp}")
+        console.print(f"\n  [bold green]Done.[/bold green] Open [bold]{root}[/bold] in Claude Code and type [cyan]/scaffold[/cyan]\n")
 
 
 @app.command()
@@ -337,6 +500,84 @@ def rule_list(
     console.print(table)
 
 
+# ── agent subcommands ─────────────────────────────────────────────────────────
+
+_AGENT_TEMPLATE = """\
+---
+name: {name}
+description: Describe when Claude should spawn this agent (role, not action — e.g. "reviews X for Y")
+---
+
+# {name}
+
+## Role
+
+Describe what this agent does.
+
+## Steps
+
+### 1 — Discover context
+
+Read CLAUDE.md, project manifest, and relevant source files.
+
+### 2 — Perform task
+
+What the agent should do.
+
+### 3 — Output
+
+What the agent should return when done.
+"""
+
+
+@agent_app.command("add")
+def agent_add(
+    name: str = typer.Argument(..., help="Agent name (e.g. 'security-reviewer')"),
+    project_dir: str = typer.Option(".", "--dir", "-d"),
+) -> None:
+    """Create a new subagent in .claude/agents/."""
+    root = Path(project_dir).resolve()
+    dest = root / ".claude" / "agents" / f"{name}.md"
+    dest.parent.mkdir(parents=True, exist_ok=True)
+
+    if dest.exists():
+        console.print(f"  [yellow]·[/yellow]  .claude/agents/{name}.md already exists")
+        return
+
+    dest.write_text(_AGENT_TEMPLATE.format(name=name), encoding="utf-8")
+    console.print(f"  [green]✓[/green]  Created .claude/agents/{name}.md")
+    console.print(f"  [dim]Edit the description so Claude knows when to spawn it.[/dim]")
+
+
+@agent_app.command("list")
+def agent_list(
+    project_dir: str = typer.Option(".", "--dir", "-d"),
+) -> None:
+    """List all subagents in .claude/agents/."""
+    root = Path(project_dir).resolve()
+    agents_dir = root / ".claude" / "agents"
+
+    if not agents_dir.exists():
+        console.print("  [yellow]·[/yellow]  No .claude/agents/ found. Run [cyan]nexus init[/cyan] first.")
+        return
+
+    agents = sorted(agents_dir.glob("*.md"))
+    if not agents:
+        console.print("  [yellow]·[/yellow]  No agents yet. Run [cyan]nexus agent add <name>[/cyan]")
+        return
+
+    table = Table(show_header=True, header_style="dim")
+    table.add_column("Agent", style="cyan")
+    table.add_column("Source")
+
+    builtins = set(_BUILTIN_AGENTS)
+    for a in agents:
+        source = "built-in" if a.name in builtins else "custom"
+        table.add_row(a.stem, source)
+
+    console.print(table)
+
+
 def main() -> None:
     app()
 

{nexus_dev_toolkit-3.1.0 → nexus_dev_toolkit-3.1.2/nexus_dev_toolkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nexus-dev-toolkit
-Version: 3.1.0
+Version: 3.1.2
 Summary: Developer workflow toolkit for Claude Code — Day 0 scaffold + Day 1 EPAV
 Author-email: Ronald dela Cruz <rcdelacruz@users.noreply.github.com>
 License-Expression: MIT
@@ -80,7 +80,8 @@ uv tool install nexus-dev-toolkit
 
 ```bash
 cd my-project
-nexus init .
+nexus init .                    # Claude Code (default)
+nexus init . --tool opencode    # OpenCode
 ```
 
 ### 4. Place your reference docs
@@ -137,15 +138,11 @@ Each step is a built-in skill in `.claude/commands/`. Every task starts from the
 
 ## What `nexus init` Creates
 
+**Claude Code** (`nexus init .`):
 ```
 .claude/
-├── commands/
-│   ├── scaffold.md    ← /scaffold  — Day 0 one-time setup
-│   ├── evaluate.md    ← /evaluate  — orient on a task
-│   ├── plan.md        ← /plan      — blueprint, no code
-│   ├── apply.md       ← /apply     — implement the plan
-│   ├── validate.md    ← /validate  — verify acceptance criteria
-│   └── epav.md        ← /epav      — full cycle guide
+├── commands/          ← EPAV skills + 5 reviewer skills (/code-review, etc.)
+├── agents/            ← 5 reviewer subagents (code-reviewer, database-reviewer, etc.)
 └── settings.json      ← PostToolUse: graphify auto-updates after every file edit
 knowledge/
 ├── rules/             ← coding standards, arch decisions
@@ -155,17 +152,35 @@ knowledge/
 .mcp.json              ← MCP server config
 ```
 
+**OpenCode** (`nexus init . --tool opencode`):
+```
+.opencode/
+├── commands/          ← same EPAV skills + reviewer skills
+├── agents/            ← same reviewer subagents (adapted for OpenCode)
+└── plugins/
+    └── graphify.js    ← tool.execute.after: graphify auto-update
+knowledge/             ← same structure
+opencode.json          ← MCP server config
+```
+
 ---
 
 ## Commands
 
 ```bash
-nexus init .                 # set up .claude/commands/ + knowledge/ + .mcp.json
-nexus skill add code-review  # create a custom skill in .claude/commands/
-nexus skill list             # list all skills
-nexus rule add api-standards # create a rule in knowledge/rules/
-nexus rule list              # list all rules
-nexus update                 # update to latest version
+nexus init .                      # Claude Code — set up .claude/ + knowledge/ + .mcp.json
+nexus init . --tool opencode      # OpenCode — set up .opencode/ + knowledge/ + opencode.json
+nexus --version                   # show installed version
+nexus update                      # update to latest version
+
+nexus skill list                  # list all skills in .claude/commands/
+nexus skill add my-review         # create a custom skill
+
+nexus agent list                  # list all subagents in .claude/agents/
+nexus agent add my-agent          # create a custom subagent
+
+nexus rule list                   # list all rules in knowledge/rules/
+nexus rule add api-standards      # create a project rule
 ```
 
 ---

{nexus_dev_toolkit-3.1.0 → nexus_dev_toolkit-3.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nexus-dev-toolkit"
-version = "3.1.0"
+version = "3.1.2"
 description = "Developer workflow toolkit for Claude Code — Day 0 scaffold + Day 1 EPAV"
 authors = [
     {name = "Ronald dela Cruz", email = "rcdelacruz@users.noreply.github.com"}

{nexus_dev_toolkit-3.1.0 → nexus_dev_toolkit-3.1.2}/tests/test_cli.py

@@ -103,3 +103,50 @@ def test_rule_list(tmp_project):
     result = runner.invoke(app, ["rule", "list", "--dir", str(tmp_project)])
     assert result.exit_code == 0
     assert "api-standards" in result.output
+
+
+def test_init_opencode_creates_commands(tmp_project):
+    result = runner.invoke(app, ["init", str(tmp_project), "--tool", "opencode"])
+    assert result.exit_code == 0
+    commands_dir = tmp_project / ".opencode" / "commands"
+    assert commands_dir.exists()
+    for skill in _BUILTIN_SKILLS:
+        assert (commands_dir / skill).exists(), f"Missing skill: {skill}"
+
+
+def test_init_opencode_creates_agents(tmp_project):
+    result = runner.invoke(app, ["init", str(tmp_project), "--tool", "opencode"])
+    assert result.exit_code == 0
+    agents_dir = tmp_project / ".opencode" / "agents"
+    assert agents_dir.exists()
+    for agent in _BUILTIN_AGENTS:
+        assert (agents_dir / agent).exists(), f"Missing agent: {agent}"
+
+
+def test_init_opencode_creates_plugin(tmp_project):
+    runner.invoke(app, ["init", str(tmp_project), "--tool", "opencode"])
+    plugin = tmp_project / ".opencode" / "plugins" / "graphify.js"
+    assert plugin.exists()
+    assert "tool.execute.after" in plugin.read_text()
+
+
+def test_init_opencode_creates_opencode_json(tmp_project):
+    runner.invoke(app, ["init", str(tmp_project), "--tool", "opencode"])
+    config = tmp_project / "opencode.json"
+    assert config.exists()
+    data = json.loads(config.read_text())
+    assert "nexus-mcp" in data["mcp"]
+    assert data["mcp"]["nexus-mcp"]["type"] == "local"
+    assert data["mcp"]["nexus-mcp"]["command"][0] == "uvx"
+
+
+def test_init_opencode_idempotent(tmp_project):
+    runner.invoke(app, ["init", str(tmp_project), "--tool", "opencode"])
+    result = runner.invoke(app, ["init", str(tmp_project), "--tool", "opencode"])
+    assert result.exit_code == 0
+    assert "Already initialized" in result.output
+
+
+def test_init_unknown_tool(tmp_project):
+    result = runner.invoke(app, ["init", str(tmp_project), "--tool", "cursor"])
+    assert result.exit_code == 1