ai-dev-cli-tools 0.5.0a1__py3-none-any.whl

ai_dev_tools/cache/validation.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import json
+import os
+import platform
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+
+from ai_dev_tools.cache.repository import repository_fingerprint
+from ai_dev_tools.utils.subprocess import CommandResult
+
+CACHE_SCHEMA_VERSION = "1"
+DEFAULT_MAX_ENTRIES = 200
+DEFAULT_MAX_BYTES = 100 * 1024 * 1024
+
+
+def validation_cache_key(
+    entries: object,
+    command: list[str],
+    workspace: str,
+) -> str:
+    return repository_fingerprint(
+        entries,
+        workspace,
+        (
+            *command,
+            platform.system(),
+            platform.machine(),
+            sys.version,
+        ),
+    )
+
+
+def load_validation_result(
+    root: Path,
+    key: str,
+    command: list[str],
+) -> CommandResult | None:
+    path = _cache_path(root, key)
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if (
+        not isinstance(value, dict)
+        or value.get("schema_version") != CACHE_SCHEMA_VERSION
+        or value.get("key") != key
+        or value.get("command") != command
+        or value.get("exit_code") != 0
+    ):
+        return None
+    stdout = value.get("stdout")
+    stderr = value.get("stderr")
+    if not isinstance(stdout, str) or not isinstance(stderr, str):
+        return None
+    return CommandResult(
+        command=command,
+        exit_code=0,
+        stdout=stdout,
+        stderr=stderr,
+        duration_seconds=0.0,
+        timed_out=False,
+        cached=True,
+    )
+
+
+def store_validation_result(root: Path, key: str, result: CommandResult) -> Path | None:
+    if result.exit_code != 0 or result.timed_out:
+        return None
+    path = _cache_path(root, key)
+    payload: dict[str, object] = {
+        "schema_version": CACHE_SCHEMA_VERSION,
+        "key": key,
+        "command": result.command,
+        "exit_code": result.exit_code,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+        "duration_seconds": result.duration_seconds,
+        "created_at": datetime.now(UTC).isoformat(),
+    }
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(".tmp")
+    temporary.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    os.replace(temporary, path)
+    prune_validation_cache(root)
+    return path
+
+
+def validation_cache_stats(root: Path) -> dict[str, int]:
+    directory = root.resolve() / ".ai" / "cache" / "checks"
+    files = list(directory.glob("*.json")) if directory.exists() else []
+    sizes = [_safe_size(path) for path in files]
+    return {"entries": len(files), "bytes": sum(sizes)}
+
+
+def prune_validation_cache(
+    root: Path,
+    *,
+    max_entries: int = DEFAULT_MAX_ENTRIES,
+    max_bytes: int = DEFAULT_MAX_BYTES,
+) -> dict[str, int]:
+    directory = root.resolve() / ".ai" / "cache" / "checks"
+    files = sorted(
+        directory.glob("*.json") if directory.exists() else [],
+        key=_safe_mtime,
+        reverse=True,
+    )
+    kept = 0
+    kept_bytes = 0
+    removed = 0
+    removed_bytes = 0
+    for path in files:
+        size = _safe_size(path)
+        if kept < max(max_entries, 0) and kept_bytes + size <= max(max_bytes, 0):
+            kept += 1
+            kept_bytes += size
+            continue
+        try:
+            path.unlink()
+        except OSError:
+            continue
+        removed += 1
+        removed_bytes += size
+    return {
+        "entries": kept,
+        "bytes": kept_bytes,
+        "removed": removed,
+        "removed_bytes": removed_bytes,
+        "max_entries": max_entries,
+        "max_bytes": max_bytes,
+    }
+
+
+def clear_validation_cache(root: Path) -> dict[str, int]:
+    return prune_validation_cache(root, max_entries=0, max_bytes=0)
+
+
+def _safe_size(path: Path) -> int:
+    try:
+        return path.stat().st_size
+    except OSError:
+        return 0
+
+
+def _safe_mtime(path: Path) -> int:
+    try:
+        return path.stat().st_mtime_ns
+    except OSError:
+        return 0
+
+
+def _cache_path(root: Path, key: str) -> Path:
+    return root.resolve() / ".ai" / "cache" / "checks" / f"{key}.json"

ai_dev_tools/cli.py

@@ -0,0 +1,387 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Callable
+from pathlib import Path
+
+from ai_dev_tools import __version__
+from ai_dev_tools.models.report import Report
+
+CommandHandler = Callable[[Path], Report]
+
+
+EXIT_SUCCESS = 0
+EXIT_FAILED = 1
+EXIT_USAGE = 2
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="ai-dev")
+    parser.add_argument("--version", action="version", version=f"ai-dev {__version__}")
+    parser.add_argument("--project", type=Path, default=Path.cwd(), help="Project directory")
+    parser.add_argument("--json", action="store_true", help="Print JSON instead of text")
+    parser.add_argument("--quiet", action="store_true", help="Only print errors and artifact paths")
+
+    sub = parser.add_subparsers(dest="command", required=True)
+    for name in ["doctor", "scan"]:
+        sub.add_parser(name)
+
+    bootstrap = sub.add_parser("bootstrap")
+    bootstrap.add_argument("--dry-run", action="store_true")
+    bootstrap.add_argument("--explain", action="store_true")
+    bootstrap.add_argument("--create-env", action="store_true")
+
+    run = sub.add_parser("run")
+    run.add_argument("--dry-run", action="store_true")
+    run.add_argument("--explain", action="store_true")
+    run.add_argument("--foreground", action="store_true")
+    run.add_argument("--timeout", type=int, default=300)
+    run.add_argument("--ready-http")
+    run.add_argument("--ready-tcp")
+    run.add_argument("--startup-timeout", type=int, default=10)
+    run.add_argument("--startup-log-lines", type=int, default=50)
+
+    stop = sub.add_parser("stop")
+    stop.add_argument("--explain", action="store_true")
+    stop.add_argument("--timeout", type=int, default=10)
+    map_parser = sub.add_parser("map")
+    map_parser.add_argument("--max-files", type=int, default=500)
+    map_parser.add_argument("--max-depth", type=int, default=6)
+
+    check = sub.add_parser("check")
+    check.add_argument("--mode", choices=["fast", "changed", "full"], default="fast")
+    check.add_argument("--jobs", type=int, default=1)
+    check.add_argument("--no-cache", action="store_true")
+    check.add_argument("--resume", action="store_true")
+    check.add_argument("--policy", choices=["complete", "feedback-first"], default="complete")
+    check.add_argument(
+        "--explain", action="store_true", help="Show selected checks without running them"
+    )
+
+    cache = sub.add_parser("cache")
+    cache_sub = cache.add_subparsers(dest="cache_command", required=True)
+    for action in ["status", "prune", "clear"]:
+        cache_sub.add_parser(action)
+
+    index = sub.add_parser("index")
+    index_sub = index.add_subparsers(dest="index_command", required=True)
+    for action in ["status", "update", "rebuild"]:
+        index_sub.add_parser(action)
+
+    test = sub.add_parser("test")
+    test_sub = test.add_subparsers(dest="test_command", required=True)
+    test_sub.add_parser("affected")
+
+    logs = sub.add_parser("logs")
+    logs_sub = logs.add_subparsers(dest="logs_command", required=True)
+    logs_summary = logs_sub.add_parser("summarize")
+    logs_summary.add_argument("log_path", nargs="?", type=Path)
+    logs_summary.add_argument("--tool", default="auto")
+
+    context = sub.add_parser("context")
+    context_sub = context.add_subparsers(dest="context_command", required=True)
+    context_build = context_sub.add_parser("build")
+    context_build.add_argument("--task", default="")
+    context_build.add_argument(
+        "--profile",
+        choices=["default", "minimal", "debug", "review", "full"],
+        default="default",
+    )
+    context_build.add_argument("--max-chars", type=int, default=50_000)
+    context_build.add_argument("--max-files", type=int, default=30)
+    context_build.add_argument("--max-file-chars", type=int, default=8_000)
+    context_build.add_argument("--max-diff-chars", type=int, default=15_000)
+    context_build.add_argument("--include", action="append", default=[])
+    context_build.add_argument("--exclude", action="append", default=[])
+    context_build.add_argument("--changed-only", action="store_true")
+    context_build.add_argument("--staged-only", action="store_true")
+    context_build.add_argument("--no-git", action="store_true")
+    context_build.add_argument("--format", choices=["markdown", "json", "both"], default="both")
+    context_build.add_argument("--output", type=Path)
+    context_build.add_argument("--explain", action="store_true")
+    context_build.add_argument("--incremental", action="store_true")
+
+    git = sub.add_parser("git")
+    git_sub = git.add_subparsers(dest="git_command", required=True)
+    git_sub.add_parser("status")
+    git_sub.add_parser("inspect")
+
+    completion = sub.add_parser("completion")
+    completion.add_argument("shell", choices=["bash", "zsh", "fish", "powershell"])
+
+    feedback = sub.add_parser("feedback")
+    feedback.add_argument("--task", default="")
+    feedback.add_argument("--explain", action="store_true")
+    feedback.add_argument("--jobs", type=int, default=4)
+
+    session = sub.add_parser("session")
+    session_sub = session.add_subparsers(dest="session_command", required=True)
+    session_sub.add_parser("status")
+
+    baseline = sub.add_parser("baseline")
+    baseline_sub = baseline.add_subparsers(dest="baseline_command", required=True)
+    baseline_sub.add_parser("list")
+    for action in ("create", "compare"):
+        baseline_action = baseline_sub.add_parser(action)
+        baseline_action.add_argument("name")
+
+    explain = sub.add_parser("explain")
+    explain.add_argument("reference")
+    explain.add_argument("--tail", type=int, default=100)
+
+    sub.add_parser("diagnostics")
+    sub.add_parser("capabilities")
+    sub.add_parser("finish")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(_normalize_global_flags(argv))
+    project_root = args.project.resolve()
+    if args.command == "completion":
+        from ai_dev_tools.completion import render_completion
+
+        print(render_completion(args.shell), end="")
+        return EXIT_SUCCESS
+    report = _dispatch(args, project_root).finish()
+    if args.json:
+        print(json.dumps(report.to_dict(), indent=2, sort_keys=True))
+    elif not args.quiet:
+        _print_text(report)
+    else:
+        for artifact in report.artifacts:
+            print(artifact.path)
+    return EXIT_SUCCESS if report.status in {"success", "warning", "partial"} else EXIT_FAILED
+
+
+def _normalize_global_flags(argv: list[str] | None) -> list[str] | None:
+    if argv is None:
+        argv = sys.argv[1:]
+    normalized = list(argv)
+    moved: list[str] = []
+    for flag in ("--json", "--quiet"):
+        if flag in normalized:
+            normalized = [item for item in normalized if item != flag]
+            moved.append(flag)
+    if "--project" in normalized:
+        index = normalized.index("--project")
+        if index + 1 < len(normalized) and index != 0:
+            project_pair = normalized[index : index + 2]
+            del normalized[index : index + 2]
+            moved.extend(project_pair)
+    return [*moved, *normalized]
+
+
+def _dispatch(args: argparse.Namespace, project_root: Path) -> Report:
+    command = args.command
+    if command == "run":
+        from ai_dev_tools.runtime import RunOptions, run_application
+
+        return run_application(
+            project_root,
+            RunOptions(
+                explain=args.explain,
+                dry_run=args.dry_run,
+                foreground=args.foreground,
+                timeout_seconds=args.timeout,
+                readiness_http=args.ready_http,
+                readiness_tcp=args.ready_tcp,
+                startup_timeout_seconds=args.startup_timeout,
+                startup_log_lines=args.startup_log_lines,
+            ),
+        )
+    if command == "stop":
+        from ai_dev_tools.runtime import stop_application
+
+        return stop_application(
+            project_root,
+            explain=args.explain,
+            timeout_seconds=args.timeout,
+        )
+    if command == "test" and args.test_command == "affected":
+        command = "check"
+        args.mode = "changed"
+        args.explain = False
+        args.jobs = 1
+        args.no_cache = False
+        args.resume = False
+        args.policy = "complete"
+    if command == "logs" and args.logs_command == "summarize":
+        from ai_dev_tools.parsers.logs import summarize_latest_log, summarize_log_file
+
+        if args.log_path is not None:
+            return summarize_log_file(project_root, args.log_path, tool=args.tool)
+        return summarize_latest_log(project_root)
+    if command == "context" and args.context_command == "build":
+        from ai_dev_tools.context import ContextOptions, build_context
+
+        return build_context(
+            project_root,
+            ContextOptions(
+                task=args.task,
+                profile=args.profile,
+                max_chars=args.max_chars,
+                max_files=args.max_files,
+                max_file_chars=args.max_file_chars,
+                max_diff_chars=args.max_diff_chars,
+                include=tuple(args.include),
+                exclude=tuple(args.exclude),
+                changed_only=args.changed_only,
+                staged_only=args.staged_only,
+                no_git=args.no_git,
+                output=args.output,
+                format=args.format,
+                explain=args.explain,
+                incremental=args.incremental,
+            ),
+        )
+    if command == "bootstrap":
+        from ai_dev_tools.runners.bootstrap import BootstrapOptions, run_bootstrap
+
+        return run_bootstrap(
+            project_root,
+            BootstrapOptions(
+                dry_run=args.dry_run,
+                explain=args.explain,
+                create_env=args.create_env,
+            ),
+        )
+    if command == "doctor":
+        from ai_dev_tools.detectors.environment import run_doctor
+
+        return run_doctor(project_root)
+    if command == "scan":
+        from ai_dev_tools.detectors.project import scan_project
+
+        return scan_project(project_root)
+    if command == "map":
+        from ai_dev_tools.detectors.repository_map import map_repository
+
+        return map_repository(project_root, max_files=args.max_files, max_depth=args.max_depth)
+    if command == "check":
+        from ai_dev_tools.runners.check import run_check
+
+        return run_check(
+            project_root,
+            mode=args.mode,
+            explain=args.explain,
+            jobs=args.jobs,
+            use_cache=not args.no_cache,
+            policy=args.policy,
+            resume=args.resume,
+        )
+    if command == "cache":
+        from ai_dev_tools.runners.cache import run_cache
+
+        return run_cache(project_root, args.cache_command)
+    if command == "index":
+        from ai_dev_tools.runners.index import run_index
+
+        return run_index(project_root, args.index_command)
+    if command == "feedback":
+        from ai_dev_tools.runners.feedback import FeedbackOptions, run_feedback
+
+        return run_feedback(
+            project_root,
+            FeedbackOptions(task=args.task, explain=args.explain, jobs=args.jobs),
+        )
+    if command == "session" and args.session_command == "status":
+        from ai_dev_tools.runners.feedback import run_session_status
+
+        return run_session_status(project_root)
+    if command == "baseline":
+        from ai_dev_tools.runners.baseline import run_baseline
+
+        return run_baseline(
+            project_root,
+            args.baseline_command,
+            getattr(args, "name", None),
+        )
+    if command == "explain":
+        from ai_dev_tools.reporters.progressive import run_explain
+
+        return run_explain(project_root, args.reference, args.tail)
+    if command == "diagnostics":
+        from ai_dev_tools.runners.diagnostics import run_diagnostics
+
+        return run_diagnostics(project_root)
+    if command == "capabilities":
+        return _capabilities_report(project_root)
+    if command == "git":
+        from ai_dev_tools.git.inspect import inspect_git
+
+        return inspect_git(project_root, detailed=args.git_command == "inspect")
+    if command == "finish":
+        from ai_dev_tools.runners.finish import run_finish
+
+        return run_finish(project_root)
+    raise SystemExit(EXIT_USAGE)
+
+
+def _capabilities_report(project_root: Path) -> Report:
+    report = Report(command="capabilities", project_root=project_root)
+    implemented = [
+        "doctor",
+        "scan",
+        "map",
+        "check",
+        "test affected",
+        "cache status",
+        "cache prune",
+        "cache clear",
+        "index status",
+        "index update",
+        "index rebuild",
+        "logs summarize",
+        "context build",
+        "bootstrap",
+        "run",
+        "stop",
+        "git status",
+        "git inspect",
+        "finish",
+        "feedback",
+        "session status",
+        "baseline create",
+        "baseline compare",
+        "baseline list",
+        "explain",
+        "diagnostics",
+        "capabilities",
+    ]
+    planned: list[str] = []
+    report.summary = {
+        "implemented": implemented,
+        "planned": planned,
+        "deprecated": [],
+        "commands": {name: "implemented" for name in implemented}
+        | {name: "planned" for name in planned},
+        "quality": {
+            "implemented": implemented,
+            "unit_tested": implemented,
+            "integration_tested": ["scan", "git status", "git inspect", "context build"],
+            "cross_platform_ci_verified": [],
+            "ci_status": "BLOCKED_EXTERNAL",
+        },
+    }
+    return report
+
+
+def _print_text(report: Report) -> None:
+    print(f"STATUS: {report.status.upper()}")
+    print(f"COMMAND: {report.command}")
+    print(f"DURATION: {report.duration_seconds}s")
+    for key, value in report.summary.items():
+        print(f"{key.upper()}: {value}")
+    if report.issues:
+        print("ISSUES:")
+        for issue in report.issues:
+            location = f" [{issue.location}]" if issue.location else ""
+            print(f"- {issue.severity}: {issue.message}{location}")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ai_dev_tools/completion.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+TOP_LEVEL_COMMANDS = (
+    "doctor scan bootstrap run stop map check test logs context cache index "
+    "baseline explain feedback session diagnostics git "
+    "capabilities finish completion"
+)
+GLOBAL_FLAGS = "--project --json --quiet --help --version"
+
+
+def render_completion(shell: str) -> str:
+    if shell == "bash":
+        return _bash()
+    if shell == "zsh":
+        return _zsh()
+    if shell == "fish":
+        return _fish()
+    if shell == "powershell":
+        return _powershell()
+    raise ValueError(f"Unsupported shell: {shell}")
+
+
+def _bash() -> str:
+    return f'''_ai_dev_complete() {{
+  local current="${{COMP_WORDS[COMP_CWORD]}}"
+  COMPREPLY=($(compgen -W "{TOP_LEVEL_COMMANDS} {GLOBAL_FLAGS}" -- "$current"))
+}}
+complete -F _ai_dev_complete ai-dev
+'''
+
+
+def _zsh() -> str:
+    words = " ".join(TOP_LEVEL_COMMANDS.split() + GLOBAL_FLAGS.split())
+    return f"""#compdef ai-dev
+_ai_dev() {{
+  local -a candidates
+  candidates=({words})
+  compadd -- $candidates
+}}
+compdef _ai_dev ai-dev
+"""
+
+
+def _fish() -> str:
+    lines = ["complete -c ai-dev -f"]
+    lines.extend(
+        f"complete -c ai-dev -n '__fish_use_subcommand' -a '{item}'"
+        for item in TOP_LEVEL_COMMANDS.split()
+    )
+    lines.extend(
+        f"complete -c ai-dev -l '{item[2:]}'"
+        for item in GLOBAL_FLAGS.split()
+        if item.startswith("--")
+    )
+    return "\n".join(lines) + "\n"
+
+
+def _powershell() -> str:
+    candidates = ", ".join(
+        f"'{item}'" for item in TOP_LEVEL_COMMANDS.split() + GLOBAL_FLAGS.split()
+    )
+    return f"""Register-ArgumentCompleter -Native -CommandName ai-dev -ScriptBlock {{
+  param($wordToComplete, $commandAst, $cursorPosition)
+  @({candidates}) |
+    Where-Object {{ $_ -like "$wordToComplete*" }} |
+    ForEach-Object {{
+      [System.Management.Automation.CompletionResult]::new(
+        $_, $_, 'ParameterValue', $_
+      )
+    }}
+}}
+"""