devflow-toolkit 0.3.0__py3-none-any.whl

devflow/adapters/registry.py

@@ -0,0 +1,41 @@
+"""Registry of supported agent harness adapters."""
+
+from __future__ import annotations
+
+from devflow.adapters.base import HarnessAdapter
+from devflow.adapters.claude_code import ClaudeCodeAdapter
+from devflow.adapters.codex import CodexAdapter
+from devflow.adapters.kiro import KiroAdapter
+from devflow.adapters.opencode import OpenCodeAdapter
+from devflow.core.config import canonical_harness_name
+
+
+def _create_registry() -> dict[str, HarnessAdapter]:
+  adapters: list[HarnessAdapter] = [
+    CodexAdapter(),
+    OpenCodeAdapter(),
+    ClaudeCodeAdapter(),
+    KiroAdapter(),
+  ]
+  return {adapter.name: adapter for adapter in adapters}
+
+
+_REGISTRY = _create_registry()
+
+
+def get_adapter(name: str) -> HarnessAdapter | None:
+  """Return the adapter for a harness name, or None when disabled."""
+  canonical = canonical_harness_name(name)
+  if canonical in {"auto", "none"}:
+    return None
+  return _REGISTRY.get(canonical)
+
+
+def adapter_names() -> tuple[str, ...]:
+  """Return the concrete harness names in stable order."""
+  return tuple(_REGISTRY)
+
+
+def adapters() -> tuple[HarnessAdapter, ...]:
+  """Return all registered adapters."""
+  return tuple(_REGISTRY.values())

devflow/cli.py

@@ -0,0 +1,39 @@
+"""Command-line interface for DevFlow Toolkit."""
+
+from importlib.metadata import PackageNotFoundError, version as package_version
+
+import typer
+from rich.console import Console
+
+from devflow.commands.approve import approve as approve_command
+from devflow.commands.init import init as init_command
+from devflow.commands.spec import spec as spec_command
+from devflow.commands.status import status as status_command
+
+app = typer.Typer(
+  name="devflow",
+  help="AI Agent Development Toolkit",
+  no_args_is_help=True,
+)
+
+console = Console()
+
+
+app.command("init")(init_command)
+app.command("spec")(spec_command)
+app.command("approve")(approve_command)
+app.command("status")(status_command)
+
+
+@app.command()
+def version() -> None:
+  """Show package version."""
+  try:
+    current_version = package_version("devflow-toolkit")
+  except PackageNotFoundError:
+    current_version = "0.3.0"
+  console.print(f"DevFlow v{current_version}")
+
+
+if __name__ == "__main__":
+  app()

devflow/commands/__init__.py

@@ -0,0 +1,6 @@
+"""Public command implementations for DevFlow."""
+
+from devflow.commands.init import init
+from devflow.commands.spec import spec
+
+__all__ = ["init", "spec"]

devflow/commands/approve.py

@@ -0,0 +1,98 @@
+"""Implementation of the devflow approve command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from devflow.core.artifacts.errors import ArtifactError
+from devflow.core.config import ConfigError, ConfigManager
+from devflow.core.discovery import DiscoveryError
+from devflow.core.project import ProjectDetector
+from devflow.core.state import (
+  StateError,
+  UnsupportedStageError,
+  WorkflowLocator,
+  WorkflowStateManager,
+)
+
+console = Console()
+error_console = Console(stderr=True)
+
+
+def approve(
+  spec_id: str = typer.Argument(
+    ...,
+    help="Change id (001) or change directory (001-add-health).",
+  ),
+  path: Path = typer.Argument(
+    Path("."),
+    help="Project root or a path inside it.",
+  ),
+  stage: str = typer.Option(
+    "spec",
+    "--stage",
+    help="Stage to approve. Only 'spec' is available in this release.",
+  ),
+) -> None:
+  """Approve the validated artifacts of a workflow stage."""
+  try:
+    _approve(spec_id, path, stage)
+  except (
+    ConfigError,
+    DiscoveryError,
+    StateError,
+    ArtifactError,
+    FileNotFoundError,
+    NotADirectoryError,
+    OSError,
+  ) as error:
+    error_console.print(f"[red]Error:[/red] {error}")
+    raise typer.Exit(code=1) from error
+
+
+def _approve(spec_id: str, path: Path, stage: str) -> None:
+  normalized = stage.strip().lower()
+  if normalized != "spec":
+    msg = (
+      f"Stage '{stage}' is not available in DevFlow 0.3.0. "
+      "Only the 'spec' stage can be approved."
+    )
+    raise UnsupportedStageError(msg)
+
+  root = ProjectDetector().find_root(path)
+  config = ConfigManager(root).load()
+  manager = WorkflowStateManager(
+    config.specifications_path,
+    project_root=config.root,
+  )
+  location = WorkflowLocator(config.specifications_path).find(spec_id)
+  result = manager.approve(location, normalized)
+  for warning in result.warnings:
+    console.print(f"[yellow]Warning:[/yellow] {warning}")
+
+  if not result.changed:
+    console.print(
+      f"[bold]{result.stage.capitalize()} stage is already approved "
+      f"for {location.change}.[/bold] No changes were made."
+    )
+  else:
+    console.print(
+      f"[bold green]{result.stage.capitalize()} approved for "
+      f"{location.change}.[/bold green]"
+    )
+    console.print(
+      f"[bold]Workflow status:[/bold] {result.state.status}"
+    )
+    for kind, digest in sorted(result.approval.artifacts.items()):
+      console.print(
+        f"[bold]Approval digest:[/bold] {kind} {digest}",
+        soft_wrap=True,
+      )
+  console.print(
+    "[dim]Approval is bound to the artifact digests above. "
+    "Changing an approved artifact marks it stale and blocks the "
+    "workflow until it is validated again.[/dim]"
+  )

devflow/commands/harness.py

@@ -0,0 +1,98 @@
+"""Shared harness selection and setup helpers for CLI commands."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from devflow.adapters.detector import (
+  detect_harnesses,
+  select_harness,
+)
+from devflow.adapters.registry import get_adapter
+from devflow.core.config import (
+  SUPPORTED_HARNESSES,
+  ConfigError,
+  canonical_harness_name,
+)
+from devflow.core.ports import HarnessPort, SetupResult
+
+
+def validate_harness_name(value: str) -> str:
+  """Validate and normalize a harness name from the CLI."""
+  canonical = canonical_harness_name(value)
+  if canonical not in SUPPORTED_HARNESSES:
+    msg = (
+      f"Unknown agent harness: {value}. "
+      f"Supported values: {', '.join(SUPPORTED_HARNESSES)}."
+    )
+    raise ConfigError(msg)
+  return canonical
+
+
+def resolve_harness(
+  requested: str,
+  *,
+  allow_prompt: bool,
+  require_installed: bool,
+) -> tuple[str | None, list[str]]:
+  """Resolve ``auto`` and verify that concrete harnesses exist."""
+  canonical = validate_harness_name(requested)
+  if canonical == "none":
+    return None, []
+
+  if canonical != "auto" and not require_installed:
+    return canonical, []
+
+  detected = detect_harnesses()
+  prompt = _prompt_for_harness if allow_prompt else None
+  selection = select_harness(canonical, detected, prompt=prompt)
+  return selection.harness, list(selection.warnings)
+
+
+def adapter_for(name: str) -> HarnessPort:
+  """Return an adapter or raise a configuration error."""
+  adapter = get_adapter(name)
+  if adapter is None:
+    msg = f"No adapter is available for agent harness '{name}'."
+    raise ConfigError(msg)
+  return adapter
+
+
+def print_setup_result(
+  result: SetupResult,
+  root: Path,
+  console: Console,
+) -> None:
+  """Print created, updated and skipped integration files."""
+  labels = {
+    "created": ("green", "created"),
+    "updated": ("green", "updated"),
+    "unchanged": ("dim", "already up to date"),
+    "skipped": ("yellow", "not overwritten"),
+  }
+  for change in result.changes:
+    color, label = labels.get(change.status, ("dim", change.status))
+    relative = change.path.relative_to(root)
+    console.print(f"[{color}]Agent integration {label}:[/{color}] {relative}")
+  for warning in result.warnings:
+    console.print(f"[yellow]Warning:[/yellow] {warning}")
+
+
+def _prompt_for_harness(names: list[str]) -> str | None:
+  if not sys.stdin.isatty():
+    return None
+  typer.echo("Multiple agent harnesses are installed:")
+  for name in names:
+    typer.echo(f"  - {name}")
+  while True:
+    answer = typer.prompt(
+      "Agent harness (" + "/".join(names) + ")",
+    )
+    canonical = canonical_harness_name(answer)
+    if canonical in names:
+      return canonical
+    typer.echo(f"Choose one of: {', '.join(names)}")