devcouncil 0.3.1 → 0.4.1

package/src/devcouncil/integrations/claude_assets.py

@@ -26,7 +26,9 @@ import json
 from dataclasses import dataclass
 from pathlib import Path
 
+from devcouncil.executors.advisor_tool import ADVISOR_STEERING_NUDGE
 from devcouncil.knowledge.frontmatter import build_frontmatter_markdown
+from devcouncil.integrations.clients.hooks import SESSION_START_MATCHER
 
 # Tools a DevCouncil subagent should be allowed to use: the standard read/edit/run set
 # plus the DevCouncil MCP tools it drives the task loop with. Listing the MCP tools keeps
@@ -90,7 +92,8 @@ def _slash_commands() -> list[_SlashCommand]:
                 "MCP tools to implement it: call `mcp__devcouncil__devcouncil_next_task`, then "
                 "`mcp__devcouncil__devcouncil_checkout_task` to acquire a lease, make changes only "
                 "through the policy-gated write tools, run tests, then "
-                "`mcp__devcouncil__devcouncil_verify_task` and release the lease when verified."
+                "`mcp__devcouncil__devcouncil_verify_task` and release the lease when verified. "
+                f"{ADVISOR_STEERING_NUDGE}"
             ),
             allowed_tools="Bash(dev tasks:*)",
         ),
@@ -113,7 +116,7 @@ def _slash_commands() -> list[_SlashCommand]:
             body=(
                 "Work through the repair guidance above. Apply the smallest changes that close the "
                 "blocking gaps via the policy-gated DevCouncil write tools, then re-run "
-                "`/devcouncil:verify` until the task is clean."
+                f"`/devcouncil:verify` until the task is clean. {ADVISOR_STEERING_NUDGE}"
             ),
             allowed_tools="Bash(dev repair:*)",
         ),
@@ -152,6 +155,46 @@ def _slash_commands() -> list[_SlashCommand]:
             ),
             allowed_tools="Bash(dev report:*)",
         ),
+        _SlashCommand(
+            name="map",
+            description="Build or refresh the deterministic repository map (no LLM).",
+            argument_hint="[goal]",
+            bash="dev map $ARGUMENTS",
+            body=(
+                "Summarize the repository map above: languages, frameworks, test commands, and "
+                "the most relevant entry points for the stated goal (if any). Point the user at "
+                "`.devcouncil/repo_map.json` for the full index and recommend `/devcouncil:next` "
+                "or `/devcouncil:plan` as the next step."
+            ),
+            allowed_tools="Bash(dev map:*)",
+        ),
+        _SlashCommand(
+            name="wiki",
+            description="Consult the generated codebase wiki for a topic or subsystem.",
+            argument_hint="[topic]",
+            bash="dev wiki status",
+            body=(
+                "The codebase wiki status is shown above. Use "
+                "`mcp__devcouncil__devcouncil_wiki_page` with query \"$ARGUMENTS\" (or no "
+                "arguments for the index) to read the relevant subsystem page(s), and "
+                "summarize what they say about the topic before making changes. If pages "
+                "are stale, suggest running `dev wiki update`."
+            ),
+            allowed_tools="Bash(dev wiki:*)",
+        ),
+        _SlashCommand(
+            name="supervise",
+            description="Review a recorded agent run and decide keep/revert/repair.",
+            argument_hint="[RUN-ID or TASK-ID]",
+            bash="dev runs list",
+            body=(
+                "The recorded runs are listed above. For the run the user named (or the "
+                "newest relevant one), run `dev runs supervise $ARGUMENTS` and present the "
+                "verdict with its findings. If the verdict is revert, show `dev runs diff "
+                "$ARGUMENTS` and ask before running `dev runs revert $ARGUMENTS`."
+            ),
+            allowed_tools="Bash(dev runs:*)",
+        ),
     ]
 
 
@@ -169,6 +212,34 @@ def _slash_command_markdown(cmd: _SlashCommand) -> str:
     return build_frontmatter_markdown(meta, "\n".join(lines))
 
 
+# Bash permission rules merged into .claude/settings.local.json so slash commands and
+# common hero-loop CLIs run without interactive approval. Kept here (with the slash
+# commands) so the allow-list stays in sync with generated command allowed-tools.
+_EXTRA_BASH_PERMISSIONS = (
+    "Bash(dev go:*)",
+    "Bash(dev check:*)",
+    "Bash(dev gaps:*)",
+    "Bash(dev export:*)",
+    "Bash(dev doctor:*)",
+    "Bash(devcouncil mcp-server)",
+)
+
+
+def claude_bash_permission_allow() -> list[str]:
+    """Ordered, de-duplicated Bash allow-rules for Claude Code settings merge."""
+    seen: set[str] = set()
+    rules: list[str] = []
+    for cmd in _slash_commands():
+        if cmd.allowed_tools and cmd.allowed_tools not in seen:
+            seen.add(cmd.allowed_tools)
+            rules.append(cmd.allowed_tools)
+    for rule in _EXTRA_BASH_PERMISSIONS:
+        if rule not in seen:
+            seen.add(rule)
+            rules.append(rule)
+    return rules
+
+
 def build_slash_commands(root: Path) -> list[GeneratedAsset]:
     base = root / ".claude" / "commands" / "devcouncil"
     return [
@@ -237,8 +308,9 @@ def _subagents() -> list[_Subagent]:
                 "and `devcouncil_get_diff` to inspect.\n"
                 "3. Change files only via `devcouncil_write_file` / `devcouncil_apply_patch` (the gate "
                 "rejects out-of-scope or protected paths) and run tests via `devcouncil_run_command`.\n"
-                "4. `devcouncil_verify_task`; fix any blocking gaps and re-verify.\n"
-                "5. `devcouncil_release_task` when verified.\n\n"
+                f"4. {ADVISOR_STEERING_NUDGE}\n"
+                "5. `devcouncil_verify_task`; fix any blocking gaps and re-verify.\n"
+                "6. `devcouncil_release_task` when verified.\n\n"
                 "Never touch files outside the task scope. Report the final status and remaining gaps."
             ),
         ),
@@ -314,6 +386,7 @@ def build_output_style(root: Path) -> list[GeneratedAsset]:
         "`file:line`. Do not call work done while blocking gaps remain.\n"
         "- When unsure of project conventions, consult `.devcouncil/repo_map.json` and the "
         "applicable skills before writing code.\n"
+        f"- {ADVISOR_STEERING_NUDGE}\n"
         "- Be concise: report what changed, what was verified, and what is still blocking."
     )
     return [GeneratedAsset(root / ".claude" / "output-styles" / "devcouncil.md", build_frontmatter_markdown(meta, body))]
@@ -364,23 +437,26 @@ def _marketplace_json(version: str) -> str:
 def _plugin_hooks_json(*, write_gate: bool = False) -> str:
     """hooks.json for the plugin, resolving the project root via ${CLAUDE_PROJECT_DIR}.
 
-    Assist-mode by default (no blocking write-gate) so installing the plugin into an
-    interactive session never fail-closes it. The blocking PreToolUse/PostToolUse gate is
-    included only when ``write_gate`` is True."""
+    Assist-mode by default installs refresh-only PostToolUse (never gates writes) plus
+    lifecycle hooks. The blocking PreToolUse write-gate is included only when
+    ``write_gate`` is True."""
     def cmd(event: str) -> str:
         return f'devcouncil hook {event} --client claude --project-root "${{CLAUDE_PROJECT_DIR}}"'
 
+    tool_matcher = "Bash|Write|Edit|MultiEdit"
     hooks: dict[str, list] = {
-        "Stop": [{"hooks": [{"type": "command", "command": cmd("agent-response"), "timeout": 10000}]}],
-        "SessionStart": [{"matcher": "startup|resume", "hooks": [{"type": "command", "command": cmd("session-start"), "timeout": 10000}]}],
+        "PostToolUse": [{"matcher": tool_matcher, "hooks": [{"type": "command", "command": cmd("post-tool-use"), "timeout": 10000}]}],
+        "Stop": [{"hooks": [{"type": "command", "command": cmd("agent-response"), "timeout": 150000}]}],
+        "SessionStart": [{"matcher": SESSION_START_MATCHER, "hooks": [{"type": "command", "command": cmd("session-start"), "timeout": 10000}]}],
         "UserPromptSubmit": [{"hooks": [{"type": "command", "command": cmd("user-prompt-submit"), "timeout": 10000}]}],
-        "SubagentStop": [{"hooks": [{"type": "command", "command": cmd("subagent-stop"), "timeout": 10000}]}],
+        "SessionEnd": [{"hooks": [{"type": "command", "command": cmd("session-end"), "timeout": 10000}]}],
+        "PreCompact": [{"hooks": [{"type": "command", "command": cmd("pre-compact"), "timeout": 10000}]}],
+        "PostCompact": [{"hooks": [{"type": "command", "command": cmd("post-compact"), "timeout": 10000}]}],
+        "SubagentStop": [{"hooks": [{"type": "command", "command": cmd("subagent-stop"), "timeout": 150000}]}],
         "Notification": [{"hooks": [{"type": "command", "command": cmd("notification"), "timeout": 10000}]}],
     }
     if write_gate:
-        tool_matcher = "Bash|Write|Edit|MultiEdit"
         hooks["PreToolUse"] = [{"matcher": tool_matcher, "hooks": [{"type": "command", "command": cmd("pre-tool-use"), "timeout": 10000}]}]
-        hooks["PostToolUse"] = [{"matcher": tool_matcher, "hooks": [{"type": "command", "command": cmd("post-tool-use"), "timeout": 10000}]}]
     return json.dumps({"hooks": hooks}, indent=2) + "\n"
 
 
@@ -398,6 +474,122 @@ def _plugin_mcp_json(root: Path) -> str:
     return json.dumps(config, indent=2) + "\n"
 
 
+def _plugin_lsp_json(root: Path) -> str | None:
+    """Build the plugin's ``.lsp.json`` from DevCouncil's language-server detection.
+
+    DevCouncil already knows which LSP servers match the repo's languages (it detects
+    them for the repo map); this ships that knowledge to Claude Code so the plugin grants
+    real code intelligence (go-to-definition, references, diagnostics) instead of only
+    detecting servers. One server per detected language (the preferred candidate), keyed by
+    language name, in Claude Code's documented schema: ``command`` + ``args`` +
+    ``extensionToLanguage``. The consumer still installs the binary (Claude Code flags a
+    missing one in ``/plugin`` Errors). Returns None when the repo has no supported
+    languages, so the bundle simply omits the file."""
+    from devcouncil.indexing.lsp import LspInspector
+
+    inspector = LspInspector(root)
+    ext_by_language: dict[str, dict[str, str]] = {}
+    for ext, language in LspInspector._EXTENSIONS.items():
+        ext_by_language.setdefault(language, {})[ext] = language
+
+    servers: dict[str, dict] = {}
+    for candidate in inspector.server_candidates():
+        if candidate.language in servers:
+            continue  # first (preferred) candidate per language wins
+        command = list(candidate.command)
+        entry: dict = {"command": command[0]}
+        if command[1:]:
+            entry["args"] = command[1:]
+        entry["extensionToLanguage"] = ext_by_language.get(candidate.language, {})
+        servers[candidate.language] = entry
+
+    if not servers:
+        return None
+    return json.dumps(servers, indent=2) + "\n"
+
+
+_GITHUB_WORKFLOW = """\
+# DevCouncil + Claude Code — event-driven task runner.
+#
+# Generated by `dev integrate claude-github`. This is the stable-primitive alternative to
+# Claude Code's (experimental) cloud Routines: it runs DevCouncil's verify loop on pull
+# requests and, on demand or on a schedule, hands the next task to headless Claude Code —
+# staying inside DevCouncil's evidence/verify gate the whole way.
+#
+# Setup: add an ANTHROPIC_API_KEY repository secret for the autonomous (dispatch/schedule)
+# runs. The pull_request job needs no secret; it only runs read-only verification.
+name: DevCouncil
+
+on:
+  pull_request:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 6 * * *"  # nightly task pickup (UTC); adjust or remove as needed
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  verify:
+    # Read-only DevCouncil verification on every PR — no model calls, no secrets.
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v7
+      - name: Install DevCouncil
+        run: |
+          uv tool install devcouncil
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"  # put the dev/devcouncil CLIs on PATH
+      - name: Verify project state
+        run: |
+          dev status
+          dev report
+
+  autonomous:
+    # On demand or on schedule: let headless Claude Code pick up and implement the next task
+    # through the DevCouncil MCP loop, then verify.
+    if: github.event_name != 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v7
+      - uses: actions/setup-node@v5
+        with:
+          node-version: "24"
+      - name: Install DevCouncil and Claude Code
+        run: |
+          uv tool install devcouncil
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"  # put the dev/devcouncil CLIs on PATH
+          npm install -g @anthropic-ai/claude-code
+      - name: Wire DevCouncil into Claude Code
+        run: dev integrate claude --apply
+      - name: Implement next task (headless, gated)
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        # --dangerously-skip-permissions is appropriate here: the runner is an ephemeral
+        # sandbox, and DevCouncil's own scope gate + the verify step below still constrain
+        # the result. Without it, headless Claude blocks on MCP-tool permission prompts.
+        run: |
+          claude -p --dangerously-skip-permissions --output-format json \\
+            "Use the DevCouncil MCP tools to implement the next task: call \\
+             mcp__devcouncil__devcouncil_next_task, checkout a lease, make only the \\
+             authorized changes, then verify and release the lease."
+      - name: Verify result
+        run: dev verify || true
+"""
+
+
+def build_github_workflow(root: Path) -> GeneratedAsset:
+    """Generate ``.github/workflows/devcouncil.yml``.
+
+    Delivers the event-driven-run value of Claude Code Routines using stable primitives
+    (GitHub Actions + headless Claude Code) instead of the experimental cloud API: read-only
+    DevCouncil verification on PRs, and gated autonomous task pickup on dispatch/schedule."""
+    return GeneratedAsset(root / ".github" / "workflows" / "devcouncil.yml", _GITHUB_WORKFLOW)
+
+
 def _plugin_readme() -> str:
     return (
         "# DevCouncil Claude Code plugin\n\n"
@@ -426,6 +618,11 @@ def build_plugin_bundle(
         GeneratedAsset(plugin / ".mcp.json", _plugin_mcp_json(root)),
         GeneratedAsset(plugin / "README.md", _plugin_readme()),
     ]
+    # Ship an .lsp.json (auto-discovered at plugin root) for the repo's languages, so the
+    # plugin delivers live code intelligence — omitted entirely when nothing is detected.
+    lsp_config = _plugin_lsp_json(root)
+    if lsp_config:
+        assets.append(GeneratedAsset(plugin / ".lsp.json", lsp_config))
     # Bundle command + agent copies into the plugin tree (plugin layout puts them at the
     # plugin root, not under .claude/).
     for cmd in _slash_commands():

package/src/devcouncil/integrations/clients/__init__.py

@@ -0,0 +1 @@
+"""Per-client integration adapters for coding CLIs."""

package/src/devcouncil/integrations/clients/aider.py

@@ -0,0 +1,52 @@
+"""Aider integration adapter."""
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+
+
+from devcouncil.integrations.clients import common as _common
+_project_root = _common._project_root
+_warn_if_verify_only = _common._warn_if_verify_only
+_server_args = _common._server_args
+_format_command = _common._format_command
+_quote_powershell_arg = _common._quote_powershell_arg
+_run = _common._run
+_run_capture = _common._run_capture
+_config_path = _common._config_path
+_load_raw_config = _common._load_raw_config
+_save_raw_config = _common._save_raw_config
+_load_json = _common._load_json
+_save_json = _common._save_json
+_load_json_strict = _common._load_json_strict
+_mutate_raw_config = _common._mutate_raw_config
+_batched_raw_config = _common._batched_raw_config
+_probe_mcp_tools = _common._probe_mcp_tools
+_print_command = _common._print_command
+_configure = _common._configure
+
+console = _common.console
+def _record_aider_config(project_root: Path) -> None:
+    def mutate(config: dict) -> None:
+        config.setdefault("integrations", {}).setdefault("aider", {}).update({"enabled": True})
+
+    _mutate_raw_config(project_root, mutate)
+
+
+def _configure_aider(project_root: Path, apply: bool) -> bool:
+    command = ["aider", "--yes", "--no-show-model-warnings", "--message", "<task prompt>"]
+    if not apply:
+        console.print("[bold]Aider[/bold]")
+        console.print("Built-in executor: [dim]dev run TASK-001 --executor aider[/dim]")
+        console.print("Launch command: [dim]" + _format_command(command) + "[/dim]")
+        console.print("Aider does not expose a first-party DevCouncil MCP server.")
+        return True
+
+    if not shutil.which("aider"):
+        console.print("[yellow]Aider CLI not found on PATH. Install it before using `dev run --executor aider`.[/yellow]")
+    _record_aider_config(project_root)
+    console.print("[green]Aider executor enabled in .devcouncil/config.yaml.[/green]")
+    return True
+
+

package/src/devcouncil/integrations/clients/antigravity.py

@@ -0,0 +1,87 @@
+"""Antigravity integration adapter."""
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+
+
+from devcouncil.integrations.clients import common as _common
+_project_root = _common._project_root
+_warn_if_verify_only = _common._warn_if_verify_only
+_server_args = _common._server_args
+_format_command = _common._format_command
+_quote_powershell_arg = _common._quote_powershell_arg
+_run = _common._run
+_run_capture = _common._run_capture
+_config_path = _common._config_path
+_load_raw_config = _common._load_raw_config
+_save_raw_config = _common._save_raw_config
+_load_json = _common._load_json
+_save_json = _common._save_json
+_load_json_strict = _common._load_json_strict
+_mutate_raw_config = _common._mutate_raw_config
+_batched_raw_config = _common._batched_raw_config
+_probe_mcp_tools = _common._probe_mcp_tools
+_print_command = _common._print_command
+_configure = _common._configure
+
+console = _common.console
+def _antigravity_mcp_path(project_root: Path) -> Path:
+    return project_root / ".agents" / "mcp_config.json"
+
+def _antigravity_mcp_config(project_root: Path) -> dict:
+    return {
+        "mcpServers": {
+            "devcouncil": {
+                "command": "devcouncil",
+                "args": ["mcp-server"],
+                "env": {"DEVCOUNCIL_PROJECT_ROOT": str(project_root)},
+                "cwd": str(project_root),
+            }
+        }
+    }
+
+def _record_antigravity_config(project_root: Path) -> None:
+    def mutate(config: dict) -> None:
+        antigravity = config.setdefault("integrations", {}).setdefault("antigravity", {})
+        antigravity.update({
+            "enabled": True,
+            "mcp_config_path": str(_antigravity_mcp_path(project_root).relative_to(project_root)),
+        })
+
+    _mutate_raw_config(project_root, mutate)
+
+def _write_antigravity_mcp_config(project_root: Path) -> Path:
+    path = _antigravity_mcp_path(project_root)
+    data = _load_json_strict(path, "Antigravity")
+    mcp_servers = data.setdefault("mcpServers", {})
+    mcp_servers["devcouncil"] = _antigravity_mcp_config(project_root)["mcpServers"]["devcouncil"]
+    _save_json(path, data)
+    return path
+
+def _configure_antigravity(project_root: Path, apply: bool) -> bool:
+    path = _antigravity_mcp_path(project_root)
+    config = _antigravity_mcp_config(project_root)
+    if not apply:
+        console.print("[bold]Google Antigravity CLI[/bold]")
+        console.print(f"Project MCP config file: [dim]{path}[/dim]")
+        console.print(json.dumps(config, separators=(",", ":")), soft_wrap=True)
+        console.print(
+            "Direct executor command: "
+            "[dim]agy --print --print-timeout 30m "
+            '"Read and execute the DevCouncil task prompt at .devcouncil/TASK-001-antigravity-task.md."[/dim]'
+        )
+        return True
+
+    if not shutil.which("agy"):
+        console.print("[yellow]Antigravity CLI (`agy`) not found on PATH. Install it before using `dev run --executor antigravity`.[/yellow]")
+    try:
+        written = _write_antigravity_mcp_config(project_root)
+    except ValueError as exc:
+        console.print(f"[red]{exc}[/red]")
+        return False
+    _record_antigravity_config(project_root)
+    console.print(f"[green]Antigravity MCP config written:[/green] {written}")
+    return True