devtorch-cli 3.0.1__py3-none-any.whl

devtorch_cli/pr_reporter_cmd.py

@@ -0,0 +1,41 @@
+"""S29 CLI handler for `devtorch pr-report`."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from devtorch_core.github.pr_reporter import run_pr_reporter
+
+
+def cmd_pr_report(args: argparse.Namespace) -> int:
+    project_root = Path(args.path).resolve()
+    gcc_dir = project_root / ".GCC"
+    if not gcc_dir.exists():
+        print(f"error: {gcc_dir} not found. Run `devtorch init` first.", file=sys.stderr)
+        return 1
+
+    critical_concepts = [c.strip() for c in args.critical_concepts.split(",") if c.strip()] if args.critical_concepts else []
+    try:
+        result = run_pr_reporter(
+            gcc_repo_path=str(project_root),
+            base_branch=args.base,
+            head_branch=args.head,
+            repo_owner=args.repo_owner,
+            repo_name=args.repo_name,
+            pr_number=args.pr_number,
+            token=args.token,
+            critical_concepts=critical_concepts,
+            min_mcs=args.min_mcs,
+        )
+    except Exception as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+    print(f"Posted reasoning-delta comment: {result.comment_posted}")
+    print(f"Merge gate: {'ALLOWED' if result.merge_gate_allowed else 'BLOCKED'}")
+    if result.merge_gate_reasons:
+        for reason in result.merge_gate_reasons:
+            print(f"  - {reason}")
+    return 0 if result.merge_gate_allowed else 1

devtorch_cli/pre_commit_cmds.py

@@ -0,0 +1,40 @@
+"""S29 CLI handlers for `devtorch pre-commit`."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from devtorch_core.hooks.pre_commit import (
+    install_pre_commit_hook,
+    run_pre_commit_checks,
+)
+
+
+def _project_root(args: argparse.Namespace) -> Path:
+    return Path(args.path).resolve()
+
+
+def cmd_pre_commit_install(args: argparse.Namespace) -> int:
+    project_root = _project_root(args)
+    try:
+        path = install_pre_commit_hook(project_root)
+    except RuntimeError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    print(f"Installed pre-commit hook at {path}")
+    return 0
+
+
+def cmd_pre_commit_run(args: argparse.Namespace) -> int:
+    project_root = _project_root(args)
+    result = run_pre_commit_checks(project_root)
+    for check in result.checks:
+        status = "✓" if check["passed"] else "✗"
+        print(f"{status} {check['name']} (exit={check['exit_code']})")
+    if result.passed:
+        print("Pre-commit checks passed.")
+        return 0
+    print("Pre-commit checks failed.", file=sys.stderr)
+    return 1

devtorch_cli/session_cmds.py

@@ -0,0 +1,282 @@
+"""S28 CLI handlers for `devtorch session` and `devtorch simulate`."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from devtorch_core.session import (
+    ACTIVE,
+    COMPLETED,
+    PENDING,
+    AgentAssignment,
+    DisagreementResolver,
+    SessionOrchestrator,
+    SubtaskPlanner,
+    WhatIfSimulator,
+)
+
+
+def _gcc_dir(args: argparse.Namespace) -> Path:
+    return Path(args.path).resolve() / ".GCC"
+
+
+def _parse_agent_assignments(raw: list[str] | None) -> List[AgentAssignment]:
+    assignments: List[AgentAssignment] = []
+    for item in raw or []:
+        if "=" not in item:
+            print(f"error: --agent must be AGENT_ID=ROLE, got: {item}", file=sys.stderr)
+            return []
+        agent_id, role = item.split("=", 1)
+        assignments.append(AgentAssignment(agent_id=agent_id.strip(), role=role.strip()))
+    return assignments
+
+
+def _parse_positions(raw: list[str] | None) -> List[Dict[str, Any]]:
+    positions: List[Dict[str, Any]] = []
+    for item in raw or []:
+        # Format: agent=position:confidence
+        if "=" not in item:
+            print(f"error: --position must be AGENT=POSITION:CONFIDENCE, got: {item}", file=sys.stderr)
+            continue
+        agent_id, rest = item.split("=", 1)
+        confidence = 0.5
+        position = rest
+        if ":" in rest:
+            position, conf_str = rest.rsplit(":", 1)
+            try:
+                confidence = float(conf_str)
+            except ValueError:
+                pass
+        positions.append({"agent_id": agent_id.strip(), "position": position.strip(), "confidence": confidence})
+    return positions
+
+
+def cmd_session_start(args: argparse.Namespace) -> int:
+    gcc_dir = _gcc_dir(args)
+    if not gcc_dir.exists():
+        print(f"error: {gcc_dir} not found. Run `devtorch init` first.", file=sys.stderr)
+        return 1
+    agents = _parse_agent_assignments(getattr(args, "agents", []))
+    orchestrator = SessionOrchestrator(gcc_dir)
+    session = orchestrator.start_session(
+        name=args.name,
+        problem=args.problem,
+        agent_assignments=agents,
+    )
+    print(f"Started session {session.session_id}: {session.name}")
+    print(f"  status: {session.status}")
+    if session.agent_roles:
+        print("  agents:")
+        for a in session.agent_roles:
+            print(f"    {a.agent_id} -> {a.role}")
+    return 0
+
+
+def cmd_session_list(args: argparse.Namespace) -> int:
+    gcc_dir = _gcc_dir(args)
+    if not gcc_dir.exists():
+        print(f"error: {gcc_dir} not found. Run `devtorch init` first.", file=sys.stderr)
+        return 1
+    orchestrator = SessionOrchestrator(gcc_dir)
+    sessions = orchestrator.list_sessions()
+    if not sessions:
+        print("No sessions.")
+        return 0
+    print(f"{'ID':<24} {'Name':<30} {'Status':<12} {'Subtasks':>10}")
+    print("-" * 80)
+    for s in sessions:
+        total = len(s.subtasks)
+        done = sum(1 for t in s.subtasks if t.status == COMPLETED)
+        print(f"{s.session_id:<24} {s.name:<30} {s.status:<12} {done}/{total}")
+    return 0
+
+
+def cmd_session_show(args: argparse.Namespace) -> int:
+    gcc_dir = _gcc_dir(args)
+    if not gcc_dir.exists():
+        print(f"error: {gcc_dir} not found. Run `devtorch init` first.", file=sys.stderr)
+        return 1
+    orchestrator = SessionOrchestrator(gcc_dir)
+    try:
+        session = orchestrator.get_session(args.session_id)
+    except FileNotFoundError:
+        print(f"error: session {args.session_id} not found", file=sys.stderr)
+        return 1
+    print(f"Session {session.session_id}: {session.name}")
+    print(f"  status: {session.status}")
+    print(f"  problem: {session.problem}")
+    if session.assumptions:
+        print("  assumptions:")
+        for k, v in session.assumptions.items():
+            print(f"    {k}: {v}")
+    if session.agent_roles:
+        print("  agents:")
+        for a in session.agent_roles:
+            print(f"    {a.agent_id} -> {a.role}")
+    if session.subtasks:
+        print("  subtasks:")
+        for t in session.subtasks:
+            deps = f" (depends on {', '.join(t.dependencies)})" if t.dependencies else ""
+            print(f"    [{t.status}] {t.subtask_id}: {t.description}{deps}")
+    return 0
+
+
+def cmd_session_plan(args: argparse.Namespace) -> int:
+    gcc_dir = _gcc_dir(args)
+    if not gcc_dir.exists():
+        print(f"error: {gcc_dir} not found. Run `devtorch init` first.", file=sys.stderr)
+        return 1
+    orchestrator = SessionOrchestrator(gcc_dir)
+    try:
+        session = orchestrator.get_session(args.session_id)
+    except FileNotFoundError:
+        print(f"error: session {args.session_id} not found", file=sys.stderr)
+        return 1
+    problem = args.problem or session.problem
+    planner = SubtaskPlanner()
+    subtasks = planner.plan(args.session_id, problem, orchestrator)
+    print(f"Planned {len(subtasks)} subtask(s) for session {args.session_id}:")
+    for t in subtasks:
+        deps = f" (depends on {', '.join(t.dependencies)})" if t.dependencies else ""
+        print(f"  {t.subtask_id}: {t.description}{deps}")
+    return 0
+
+
+def cmd_session_next(args: argparse.Namespace) -> int:
+    gcc_dir = _gcc_dir(args)
+    if not gcc_dir.exists():
+        print(f"error: {gcc_dir} not found. Run `devtorch init` first.", file=sys.stderr)
+        return 1
+    orchestrator = SessionOrchestrator(gcc_dir)
+    planner = SubtaskPlanner()
+    subtask = planner.next_subtask(args.session_id, orchestrator)
+    if subtask is None:
+        print("No pending subtasks ready.")
+        return 0
+    print(f"Next subtask: {subtask.subtask_id}")
+    print(f"  {subtask.description}")
+    return 0
+
+
+def cmd_session_mark(args: argparse.Namespace) -> int:
+    gcc_dir = _gcc_dir(args)
+    if not gcc_dir.exists():
+        print(f"error: {gcc_dir} not found. Run `devtorch init` first.", file=sys.stderr)
+        return 1
+    orchestrator = SessionOrchestrator(gcc_dir)
+    planner = SubtaskPlanner()
+    subtask = planner.mark_subtask(args.session_id, args.subtask_id, args.status, orchestrator)
+    if subtask is None:
+        print(f"error: subtask {args.subtask_id} not found", file=sys.stderr)
+        return 1
+    print(f"Marked {subtask.subtask_id} as {subtask.status}")
+    return 0
+
+
+def cmd_session_close(args: argparse.Namespace) -> int:
+    gcc_dir = _gcc_dir(args)
+    if not gcc_dir.exists():
+        print(f"error: {gcc_dir} not found. Run `devtorch init` first.", file=sys.stderr)
+        return 1
+    orchestrator = SessionOrchestrator(gcc_dir)
+    try:
+        session = orchestrator.close_session(args.session_id)
+    except FileNotFoundError:
+        print(f"error: session {args.session_id} not found", file=sys.stderr)
+        return 1
+    print(f"Closed session {session.session_id} (status={session.status})")
+    return 0
+
+
+def cmd_session_disagree(args: argparse.Namespace) -> int:
+    gcc_dir = _gcc_dir(args)
+    if not gcc_dir.exists():
+        print(f"error: {gcc_dir} not found. Run `devtorch init` first.", file=sys.stderr)
+        return 1
+    positions = _parse_positions(getattr(args, "positions", []))
+    if not positions:
+        print("error: at least one --position required", file=sys.stderr)
+        return 1
+    resolver = DisagreementResolver(gcc_dir)
+    record = resolver.record_disagreement(args.session_id, args.concept, positions)
+    print(f"Recorded disagreement {record.disagreement_id} on '{record.concept}'")
+    print(f"  state: {record.state}")
+    for p in record.positions:
+        print(f"    {p['agent_id']}: {p['position']} (conf={p['confidence']})")
+    return 0
+
+
+def cmd_session_resolve(args: argparse.Namespace) -> int:
+    gcc_dir = _gcc_dir(args)
+    if not gcc_dir.exists():
+        print(f"error: {gcc_dir} not found. Run `devtorch init` first.", file=sys.stderr)
+        return 1
+    resolver = DisagreementResolver(gcc_dir)
+    try:
+        record = resolver.resolve(
+            args.disagreement_id,
+            human_decision=args.decision,
+        )
+    except ValueError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    print(f"Resolved disagreement {record.disagreement_id}: {record.state}")
+    if record.resolution:
+        print(f"  resolution: {record.resolution}")
+    return 0
+
+
+def cmd_session_disagreements(args: argparse.Namespace) -> int:
+    gcc_dir = _gcc_dir(args)
+    if not gcc_dir.exists():
+        print(f"error: {gcc_dir} not found. Run `devtorch init` first.", file=sys.stderr)
+        return 1
+    resolver = DisagreementResolver(gcc_dir)
+    records = resolver.list_disagreements(session_id=getattr(args, "session_id", None))
+    if not records:
+        print("No disagreements.")
+        return 0
+    print(f"{'ID':<36} {'Session':<24} {'Concept':<20} {'State':<14} {'Resolution'}")
+    print("-" * 100)
+    for r in records:
+        print(f"{r.disagreement_id:<36} {r.session_id:<24} {r.concept:<20} {r.state:<14} {r.resolution}")
+    return 0
+
+
+def cmd_simulate(args: argparse.Namespace) -> int:
+    gcc_dir = _gcc_dir(args)
+    if not gcc_dir.exists():
+        print(f"error: {gcc_dir} not found. Run `devtorch init` first.", file=sys.stderr)
+        return 1
+    assumptions: Dict[str, Any] = {}
+    for item in getattr(args, "assumptions", []) or []:
+        if "=" not in item:
+            print(f"error: --assume must be KEY=VALUE, got: {item}", file=sys.stderr)
+            return 1
+        k, v = item.split("=", 1)
+        assumptions[k.strip()] = v.strip()
+    simulator = WhatIfSimulator(gcc_dir)
+    try:
+        result = simulator.simulate(args.session_id, assumptions)
+    except ValueError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    print(f"Simulation {result.simulation_id} for session {result.session_id}")
+    print("  alternate assumptions:")
+    for k, v in result.alternate_assumptions.items():
+        print(f"    {k}: {v}")
+    print("  affected concepts:")
+    if result.affected_concepts:
+        for c in result.affected_concepts:
+            print(f"    - {c}")
+    else:
+        print("    (none)")
+    print("  predicted outcome:")
+    print(result.predicted_outcome)
+    if getattr(args, "json", False):
+        print(json.dumps(result.to_dict(), indent=2))
+    return 0

devtorch_cli-3.0.1.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: devtorch-cli
+Version: 3.0.1
+Summary: DevTorch — command-line interface for the devtorch-core governance SDK
+Author-email: Hemant Joshi <hemant@flotorch.ai>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/hemantcgi/DevTorch
+Project-URL: Repository, https://github.com/hemantcgi/DevTorch
+Project-URL: Documentation, https://github.com/hemantcgi/DevTorch/blob/main/Implementation/README.md
+Keywords: ai,agents,governance,audit,llm,reasoning,devtorch
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: devtorch-core>=3.0.1
+Provides-Extra: cloud
+Requires-Dist: devtorch-core[cloud]; extra == "cloud"
+Provides-Extra: mcp
+Requires-Dist: devtorch-core[mcp]; extra == "mcp"
+Provides-Extra: audit
+Requires-Dist: devtorch-core[audit]; extra == "audit"
+Provides-Extra: proxy
+Requires-Dist: devtorch-core[proxy]; extra == "proxy"
+Provides-Extra: wrapper
+Requires-Dist: devtorch-core[wrapper]; extra == "wrapper"
+Provides-Extra: embeddings
+Requires-Dist: devtorch-core[embeddings]; extra == "embeddings"
+Provides-Extra: broadcast
+Requires-Dist: devtorch-core[broadcast]; extra == "broadcast"
+Provides-Extra: dev
+Requires-Dist: devtorch-core[dev]; extra == "dev"
+Provides-Extra: all
+Requires-Dist: devtorch-core[all]; extra == "all"
+
+# devtorch-cli
+
+Command-line interface for [DevTorch](https://github.com/hemantcgi/DevTorch), a local-first AI governance platform.
+
+This package installs the `devtorch` command and depends on `devtorch-core`, which provides the governance SDK.
+
+## Install
+
+```bash
+pip install devtorch-cli
+```
+
+For the full experience including cloud sync, MCP, and IDE wrappers:
+
+```bash
+pip install devtorch-cli[all]
+```
+
+See the main repository README for detailed setup instructions.

devtorch_cli-3.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+devtorch_cli/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+devtorch_cli/__main__.py,sha256=yOQ0W0lH4pSVd-goEkwkH24SCS405zHwDrhsCxQqCaA,171
+devtorch_cli/audit_cmds.py,sha256=ZTVB7lmB7pYCCZpuZQscmeitfvs7-9VMe9K8wP5Fkwk,8605
+devtorch_cli/capability_role_cmds.py,sha256=_j9rpresbPs496hBNGUVDszg2hq_qAq9JLGS4Bnf6nw,2975
+devtorch_cli/main.py,sha256=dwb2Xr7OtBNJEYk8IyU8NGeEAPADlN3venV9e1ti_0o,174178
+devtorch_cli/pr_reporter_cmd.py,sha256=wb9IRAWzWWXo7-esJDaIPHJTJS9y8WoTVlE1qepHgCU,1408
+devtorch_cli/pre_commit_cmds.py,sha256=w3PeUr6z2NoP_7I98E6REuGCs_0bZjdrpsIMPNEEF-o,1113
+devtorch_cli/session_cmds.py,sha256=hA6YhFkMwE0-an5LK4SswvVIaKuO4h-9V98RnUlqPGs,10280
+devtorch_cli-3.0.1.dist-info/METADATA,sha256=tqHM3EQuI5YTAkkGm8ujbF4bA_5rmpcrvdwp3G-UD3A,2272
+devtorch_cli-3.0.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+devtorch_cli-3.0.1.dist-info/entry_points.txt,sha256=iimCDbtjqjoEbpySI9sfLJAsZmPkz2_nHtWoHFgMvIk,52
+devtorch_cli-3.0.1.dist-info/top_level.txt,sha256=FBW8lXo3q5SicN7Y27MikpGiBsjgQ_cWXE6mOUUQBPg,13
+devtorch_cli-3.0.1.dist-info/RECORD,,

devtorch_cli-3.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

devtorch_cli-3.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+devtorch = devtorch_cli.main:main

devtorch_cli-3.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+devtorch_cli