codd-dev 1.24.0__tar.gz → 1.26.0__tar.gz

{codd_dev-1.24.0 → codd_dev-1.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 1.24.0
+Version: 1.26.0
 Summary: CoDD: Coherence-Driven Development — cross-artifact change impact analysis
 Project-URL: Homepage, https://github.com/yohey-w/codd-dev
 Project-URL: Repository, https://github.com/yohey-w/codd-dev
@@ -20,6 +20,7 @@ Requires-Dist: jinja2>=3.1.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: tomli>=2.0.1; python_version < '3.11'
 Requires-Dist: watchdog>=4.0.0
+Requires-Dist: websocket-client>=1.8.0
 Provides-Extra: ai
 Provides-Extra: api-parsers
 Requires-Dist: graphql-core>=3.2.0; extra == 'api-parsers'

{codd_dev-1.24.0 → codd_dev-1.26.0}/codd/cli.py

@@ -2283,6 +2283,119 @@ def test_cmd(project_path: str, related: tuple[str, ...], dry_run: bool):
         raise SystemExit(1)
 
 
+@main.group()
+def llm():
+    """Manage LLM-derived considerations."""
+    pass
+
+
+@llm.command("derive")
+@click.argument("design_doc", type=click.Path(exists=True, dir_okay=False, path_type=Path))
+@click.option("--path", "project_path", default=".", help="Project root directory")
+@click.option("--ai-cmd", default=None, help="Override AI CLI command")
+@click.option("--model", default=None, help="Override AI model")
+@click.option("--force", is_flag=True, help="Bypass cached derived considerations")
+def llm_derive(design_doc: Path, project_path: str, ai_cmd: str | None, model: str | None, force: bool):
+    """Derive considerations for a design document."""
+    from codd.deployment.providers.ai_command import SubprocessAiCommand
+    from codd.deployment.providers.llm_consideration import LlmConsiderationProvider
+    from codd.llm.approval import notify_pending_considerations
+
+    project_root = Path(project_path).resolve()
+    config = _load_optional_project_config(project_root)
+    provider = LlmConsiderationProvider(
+        SubprocessAiCommand(command=ai_cmd, project_root=project_root, config=config),
+        project_root=project_root,
+        cache_dir=project_root / ".codd" / "consideration_cache",
+        model=model,
+        use_cache=not force,
+    )
+    result = provider.provide(design_doc.read_text(encoding="utf-8"), {"model": model} if model else {})
+    notify_pending_considerations(result.considerations, config)
+    click.echo(f"Derived considerations: {len(result.considerations)}")
+
+
+@llm.command("approve")
+@click.argument("consideration_id", required=False)
+@click.option("--all", "approve_all", is_flag=True, help="Approve all pending considerations")
+@click.option("--path", "project_path", default=".", help="Project root directory")
+def llm_approve(consideration_id: str | None, approve_all: bool, project_path: str):
+    """Approve one or all pending considerations."""
+    from codd.llm.approval import ApprovalCache, consideration_status, load_cached_considerations
+
+    project_root = Path(project_path).resolve()
+    considerations = load_cached_considerations(project_root)
+    by_id = {consideration.id: consideration for consideration in considerations}
+
+    if approve_all:
+        targets = [
+            consideration
+            for consideration in considerations
+            if consideration_status(consideration, project_root) == "pending"
+        ]
+    else:
+        if not consideration_id:
+            click.echo("Error: consideration_id or --all is required")
+            raise SystemExit(2)
+        if consideration_id not in by_id:
+            click.echo(f"Error: consideration not found: {consideration_id}")
+            raise SystemExit(1)
+        targets = [by_id[consideration_id]]
+
+    for consideration in targets:
+        ApprovalCache.save(consideration.id, "approved", project_root)
+    click.echo(f"Approved considerations: {len(targets)}")
+
+
+@llm.command("skip")
+@click.argument("consideration_id")
+@click.option("--path", "project_path", default=".", help="Project root directory")
+def llm_skip(consideration_id: str, project_path: str):
+    """Skip one consideration."""
+    from codd.llm.approval import ApprovalCache, load_cached_considerations
+
+    project_root = Path(project_path).resolve()
+    known = {consideration.id for consideration in load_cached_considerations(project_root)}
+    if consideration_id not in known:
+        click.echo(f"Error: consideration not found: {consideration_id}")
+        raise SystemExit(1)
+    ApprovalCache.save(consideration_id, "skipped", project_root)
+    click.echo(f"Skipped consideration: {consideration_id}")
+
+
+@llm.command("list")
+@click.option("--path", "project_path", default=".", help="Project root directory")
+@click.option("--format", "output_format", default="text", type=click.Choice(["text", "json"]))
+def llm_list(project_path: str, output_format: str):
+    """List generated considerations with approval status."""
+    from codd.llm.approval import consideration_status, consideration_to_dict, load_cached_considerations
+
+    project_root = Path(project_path).resolve()
+    rows = []
+    for consideration in sorted(load_cached_considerations(project_root), key=lambda item: item.id):
+        row = consideration_to_dict(consideration)
+        row["status"] = consideration_status(consideration, project_root)
+        rows.append(row)
+
+    if output_format == "json":
+        click.echo(json.dumps(rows, ensure_ascii=False, indent=2))
+        return
+
+    if not rows:
+        click.echo("No considerations found")
+        return
+    for row in rows:
+        description = str(row.get("description") or "")
+        click.echo(f"{row['id']}\t{row['status']}\t{description}")
+
+
+def _load_optional_project_config(project_root: Path) -> dict[str, Any]:
+    try:
+        return load_project_config(project_root)
+    except (FileNotFoundError, ValueError):
+        return {}
+
+
 @main.group()
 def dag():
     """DAG Completeness Gate commands."""
@@ -2409,6 +2522,192 @@ def dag_visualize(project_path: str):
     click.echo(render_mermaid(built_dag), nl=False)
 
 
+@dag.command("journeys")
+@click.option("--project-path", "--path", default=".", show_default=True, help="Project root directory")
+@click.option(
+    "--format",
+    "output_format",
+    default="text",
+    type=click.Choice(["text", "json"]),
+    help="Output format",
+)
+def dag_journeys(project_path: str, output_format: str):
+    """List user_journeys declared on design_doc DAG nodes."""
+    from codd.dag.builder import build_dag
+
+    project_root = Path(project_path).resolve()
+    try:
+        built_dag = build_dag(project_root)
+    except (FileNotFoundError, ValueError) as exc:
+        click.echo(f"Error: {exc}")
+        raise SystemExit(1)
+
+    journeys = _collect_dag_journeys(built_dag, project_root, _load_optional_project_config(project_root))
+    if output_format == "json":
+        click.echo(json.dumps(journeys, ensure_ascii=False, indent=2))
+        return
+
+    current_doc: str | None = None
+    for journey in journeys:
+        design_doc = journey["design_doc"]
+        if design_doc != current_doc:
+            if current_doc is not None:
+                click.echo()
+            click.echo(design_doc)
+            current_doc = design_doc
+        required = journey["required_capabilities"]
+        requires = ", ".join(required) if required else "-"
+        click.echo(f"  {journey['name']} [{journey['criticality']}]  requires: {requires}")
+
+
+@dag.command("run-journey")
+@click.argument("journey_name")
+@click.option("--project-path", "--path", default=".", show_default=True, help="Project root directory")
+@click.option(
+    "--config-section",
+    default="cdp_browser",
+    show_default=True,
+    help="verification.templates section used for browser config",
+)
+def dag_run_journey(journey_name: str, project_path: str, config_section: str):
+    """Run one declared user_journey with the CDP browser template."""
+    from codd.dag.builder import build_dag
+    from codd.deployment.providers.verification.cdp_browser import CdpBrowser
+
+    project_root = Path(project_path).resolve()
+    try:
+        config = load_project_config(project_root)
+        template_config = _journey_template_config(config, config_section)
+        built_dag = build_dag(project_root)
+    except (FileNotFoundError, ValueError) as exc:
+        click.echo(f"Error: {exc}")
+        raise SystemExit(2)
+
+    journey_record = _find_dag_journey(built_dag, journey_name, project_root, config)
+    if journey_record is None:
+        click.echo(f"Error: user_journey not found: {journey_name}")
+        raise SystemExit(2)
+
+    command = json.dumps(
+        _journey_execution_plan(project_root, journey_record, template_config),
+        sort_keys=True,
+    )
+    result = CdpBrowser(config=template_config).execute(command)
+    if result.output:
+        click.echo(result.output)
+    raise SystemExit(0 if result.passed else 1)
+
+
+def _journey_template_config(config: dict[str, Any], config_section: str) -> dict[str, Any]:
+    verification = config.get("verification")
+    templates = verification.get("templates") if isinstance(verification, dict) else None
+    if not isinstance(templates, dict) or config_section not in templates:
+        raise ValueError(f"verification.templates.{config_section} config not found")
+
+    section = templates[config_section]
+    if not isinstance(section, dict):
+        raise ValueError(f"verification.templates.{config_section} must be a mapping")
+    return dict(section)
+
+
+def _find_dag_journey(
+    dag: Any,
+    journey_name: str,
+    project_root: Path | None = None,
+    settings: dict[str, Any] | None = None,
+) -> dict[str, Any] | None:
+    for node in sorted(dag.nodes.values(), key=lambda item: item.id):
+        if node.kind != "design_doc":
+            continue
+        for journey in _node_user_journeys(node, project_root, settings):
+            if str(journey.get("name") or "") == journey_name:
+                return {
+                    "design_doc": node.path or node.id,
+                    "journey": dict(journey),
+                }
+    return None
+
+
+def _journey_execution_plan(
+    project_root: Path,
+    journey_record: dict[str, Any],
+    template_config: dict[str, Any],
+) -> dict[str, Any]:
+    journey = dict(journey_record["journey"])
+    journey_name = str(journey.get("name") or "")
+    steps = journey.get("steps")
+    return {
+        "template": "cdp_browser",
+        "test_kind": "e2e",
+        "target": _journey_target(journey),
+        "identifier": f"journey:{journey_name}",
+        "journey": journey_name,
+        "steps": steps if isinstance(steps, list) else [],
+        "project_root": str(project_root),
+        "design_doc": journey_record["design_doc"],
+        "config": template_config,
+    }
+
+
+def _journey_target(journey: dict[str, Any]) -> str:
+    steps = journey.get("steps")
+    if isinstance(steps, list):
+        for step in steps:
+            if not isinstance(step, dict):
+                continue
+            if step.get("action") == "navigate":
+                target = step.get("target") or step.get("url")
+                if target:
+                    return str(target)
+
+    target = journey.get("target") or journey.get("url")
+    return str(target or "")
+
+
+def _collect_dag_journeys(
+    dag: Any,
+    project_root: Path | None = None,
+    settings: dict[str, Any] | None = None,
+) -> list[dict[str, Any]]:
+    journeys: list[dict[str, Any]] = []
+    for node in sorted(dag.nodes.values(), key=lambda item: item.id):
+        if node.kind != "design_doc":
+            continue
+        for journey in _node_user_journeys(node, project_root, settings):
+            journeys.append(
+                {
+                    "design_doc": node.path or node.id,
+                    "name": str(journey.get("name") or ""),
+                    "criticality": str(journey.get("criticality") or ""),
+                    "required_capabilities": _string_list(journey.get("required_capabilities")),
+                }
+            )
+    return journeys
+
+
+def _node_user_journeys(
+    node: Any,
+    project_root: Path | None = None,
+    settings: dict[str, Any] | None = None,
+) -> list[dict[str, Any]]:
+    if project_root is not None:
+        from codd.dag.checks.user_journey_coherence import UserJourneyCoherenceCheck
+
+        return UserJourneyCoherenceCheck(project_root=project_root, settings=settings or {})._journey_entries(node)
+
+    attributes = getattr(node, "attributes", {}) or {}
+    value = attributes.get("user_journeys")
+    if not isinstance(value, list):
+        return []
+    return [journey for journey in value if isinstance(journey, dict)]
+
+
+def _string_list(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [str(item) for item in value if isinstance(item, str) and item]
+
+
 def _dag_result_to_dict(result: Any) -> dict[str, Any]:
     if is_dataclass(result):
         return asdict(result)
@@ -2447,6 +2746,7 @@ def _dag_result_has_findings(result: Any) -> bool:
 def _dag_result_details(result: Any) -> list[str]:
     details: list[str] = []
     for key in (
+        "message",
         "missing_impl_files",
         "orphan_edges",
         "dangling_refs",

{codd_dev-1.24.0 → codd_dev-1.26.0}/codd/dag/__init__.py

@@ -19,7 +19,7 @@ class Edge:
     from_id: str
     to_id: str
     kind: str
-    attributes: dict[str, Any] = field(default_factory=dict)
+    attributes: dict[str, Any] | None = None
 
 
 class DAG: