logicfalcon 0.1.1__py3-none-any.whl

aegis/__init__.py

@@ -0,0 +1,36 @@
+"""AEGIS AI — Enterprise-grade AI Engineering, Automated Code Review & Autonomous Debugging Platform.
+
+Public API exports for library consumers and integrations.
+"""
+
+try:
+    from packages.intelligence.debugging.service import AutonomousDebuggingService
+except (ImportError, ModuleNotFoundError):
+    class AutonomousDebuggingService:  # type: ignore[no-redef]
+        """Autonomous debugging service requires the full AEGIS AI platform backend.
+
+        This feature is unavailable in the standalone LogicFalcon CLI/SDK distribution.
+        """
+
+        def __init__(self, *args: object, **kwargs: object) -> None:
+            raise RuntimeError(
+                "AutonomousDebuggingService requires the optional AEGIS AI platform backend (apps.api). "
+                "It is not available in the standalone LogicFalcon CLI/SDK distribution."
+            )
+
+from packages.review.cli import build_parser, run_cli
+from packages.review.domain.models import FindingSeverity, ReviewReport
+from packages.review.engine import LocalReviewEngine, ReviewConfig
+
+__version__ = "0.1.1"
+
+__all__ = [
+    "AutonomousDebuggingService",
+    "FindingSeverity",
+    "LocalReviewEngine",
+    "ReviewConfig",
+    "ReviewReport",
+    "__version__",
+    "build_parser",
+    "run_cli",
+]

aegis/cli.py

@@ -0,0 +1,134 @@
+"""Unified Command-Line Interface for AEGIS AI."""
+
+import argparse
+import shutil
+import sys
+from typing import NoReturn
+
+from aegis import __version__
+from packages.intelligence.code.indexer import PythonASTParser
+from packages.intelligence.code.ts_parser import JavaScriptTypeScriptParser
+from packages.review.cli import run_cli as run_review_cli
+
+
+def run_doctor() -> int:
+    """Runs a non-destructive environment and capability diagnostic."""
+    sys.stdout.write("🛡️  AEGIS AI — System Diagnostic & Capability Doctor\n")
+    sys.stdout.write("=" * 60 + "\n")
+
+    # 1. Python version check
+    py_ver = sys.version_info
+    py_ok = py_ver >= (3, 12)
+    py_status = "PASS" if py_ok else "FAIL"
+    sys.stdout.write(f"[{py_status}] Python Version: {py_ver.major}.{py_ver.minor}.{py_ver.micro} (>= 3.12 required)\n")
+
+    # 2. Git binary check
+    git_bin = shutil.which("git")
+    git_status = "PASS" if git_bin else "WARN"
+    sys.stdout.write(f"[{git_status}] Git Executable: {git_bin or 'Not found in PATH'}\n")
+
+    # 3. Python AST parser check
+    try:
+        symbols, _deps = PythonASTParser.parse_source("test.py", "def hello(): pass")
+        ast_ok = len(symbols) == 1 and symbols[0].name == "hello"
+        ast_status = "PASS" if ast_ok else "FAIL"
+    except Exception as e:
+        ast_status = f"FAIL ({e})"
+    sys.stdout.write(f"[{ast_status}] Python AST Static Analyzer: functional\n")
+
+    # 4. Multi-language TypeScript parser check
+    try:
+        ts_res = JavaScriptTypeScriptParser().parse_source("test.ts", "function greet(): string { return 'hi'; }")
+        ts_ok = len(ts_res.symbols) == 1 and ts_res.symbols[0].name == "greet"
+        ts_status = "PASS" if ts_ok else "FAIL"
+    except Exception as e:
+        ts_status = f"FAIL ({e})"
+    sys.stdout.write(f"[{ts_status}] TypeScript/JavaScript Static Parser: functional\n")
+
+    # 5. External linter (Ruff) check
+    ruff_bin = shutil.which("ruff")
+    ruff_status = "PASS" if ruff_bin else "INFO"
+    sys.stdout.write(f"[{ruff_status}] External Linter (Ruff): {ruff_bin or 'Optional / Not installed'}\n")
+
+    # 6. Service infrastructure status (informational)
+    sys.stdout.write("[INFO] Backend Services (PostgreSQL / Redis): Optional (not required for CLI review)\n")
+    sys.stdout.write("=" * 60 + "\n")
+    sys.stdout.write("System diagnostics complete. AEGIS CLI is operational.\n")
+    return 0
+
+
+def build_root_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="aegis",
+        description="AEGIS AI — Enterprise-grade AI Engineering, Automated Code Review & Autonomous Debugging CLI",
+    )
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version=f"aegis-review {__version__}",
+        help="Show program's version number and exit.",
+    )
+
+    subparsers = parser.add_subparsers(dest="subcommand", help="Available subcommands")
+
+    # Subcommand: review
+    subparsers.add_parser(
+        "review",
+        help="Run deterministic repository intelligence & automated code review.",
+        add_help=False,  # Let review parser handle its own flags
+    )
+
+    # Subcommand: doctor
+    subparsers.add_parser(
+        "doctor",
+        help="Run environment health check, AST parser capabilities, and tool diagnostic.",
+    )
+
+    return parser
+
+
+def run_main(args: list[str] | None = None) -> int:
+    argv = sys.argv[1:] if args is None else args
+
+    # Handle direct review fallback when arguments start with review flags
+    if argv and argv[0].startswith("-") and argv[0] not in ("-v", "--version", "-h", "--help"):
+        return run_review_cli(argv)
+
+    if not argv:
+        parser = build_root_parser()
+        parser.print_help()
+        return 0
+
+    if argv[0] in ("-v", "--version"):
+        sys.stdout.write(f"aegis-review {__version__}\n")
+        return 0
+
+    if argv[0] in ("-h", "--help"):
+        parser = build_root_parser()
+        parser.print_help()
+        return 0
+
+    if argv[0] == "doctor":
+        return run_doctor()
+
+    if argv[0] == "review":
+        return run_review_cli(argv[1:])
+
+    # Fallback to standard argparsing
+    parser = build_root_parser()
+    parsed = parser.parse_args(argv)
+    if parsed.subcommand == "doctor":
+        return run_doctor()
+    elif parsed.subcommand == "review":
+        return run_review_cli(argv[1:])
+
+    parser.print_help()
+    return 0
+
+
+def main() -> NoReturn:
+    sys.exit(run_main())
+
+
+if __name__ == "__main__":
+    main()

logicfalcon/__init__.py

@@ -0,0 +1,70 @@
+"""LogicFalcon — Fast, precise engineering intelligence. Powered by AEGIS AI.
+
+LogicFalcon is an AI-powered software engineering intelligence platform for
+evidence-grounded code review, repository analysis, change-impact assessment,
+root-cause analysis, and safe fix proposals. Powered by AEGIS AI.
+"""
+
+try:
+    from packages.intelligence.debugging.service import AutonomousDebuggingService
+except (ImportError, ModuleNotFoundError):
+    class AutonomousDebuggingService:  # type: ignore[no-redef]
+        """Autonomous debugging service requires the full AEGIS AI platform backend.
+
+        This feature is unavailable in the standalone LogicFalcon CLI/SDK distribution.
+        """
+
+        def __init__(self, *args: object, **kwargs: object) -> None:
+            raise RuntimeError(
+                "AutonomousDebuggingService requires the optional AEGIS AI platform backend (apps.api). "
+                "It is not available in the standalone LogicFalcon CLI/SDK distribution."
+            )
+
+from logicfalcon.sdk import apply_fix, review, review_diff, verify_fix
+from packages.review.cli import build_parser, run_cli
+from packages.review.domain.models import (
+    FindingCategory,
+    FindingSeverity,
+    ProposedFix,
+    ReviewFinding,
+    ReviewReport,
+    ValidationStatus,
+)
+from packages.review.engine import LocalReviewEngine, ReviewConfig
+from packages.review.fix_engine import (
+    FixApplicationResult,
+    RemediationVerificationResult,
+    ReviewFixEngine,
+)
+from packages.review.validator import FindingValidator
+
+__version__ = "0.1.1"
+__product__ = "LogicFalcon"
+__tagline__ = "Fast, precise engineering intelligence."
+__platform__ = "AEGIS AI"
+
+__all__ = [
+    "AutonomousDebuggingService",
+    "FindingCategory",
+    "FindingSeverity",
+    "FindingValidator",
+    "FixApplicationResult",
+    "LocalReviewEngine",
+    "ProposedFix",
+    "RemediationVerificationResult",
+    "ReviewConfig",
+    "ReviewFinding",
+    "ReviewFixEngine",
+    "ReviewReport",
+    "ValidationStatus",
+    "__platform__",
+    "__product__",
+    "__tagline__",
+    "__version__",
+    "apply_fix",
+    "build_parser",
+    "review",
+    "review_diff",
+    "run_cli",
+    "verify_fix",
+]

logicfalcon/cli.py

@@ -0,0 +1,134 @@
+"""Unified Command-Line Interface for LogicFalcon (Powered by AEGIS AI)."""
+
+import argparse
+import shutil
+import sys
+from typing import NoReturn
+
+from logicfalcon import __platform__, __product__, __version__
+from packages.intelligence.code.indexer import PythonASTParser
+from packages.intelligence.code.ts_parser import JavaScriptTypeScriptParser
+from packages.review.cli import run_cli as run_review_cli
+
+
+def run_doctor() -> int:
+    """Runs a non-destructive environment and capability diagnostic."""
+    sys.stdout.write(f"🦅  {__product__} — System Diagnostic & Capability Doctor (Powered by {__platform__})\n")
+    sys.stdout.write("=" * 65 + "\n")
+
+    # 1. Python version check
+    py_ver = sys.version_info
+    py_ok = py_ver >= (3, 12)
+    py_status = "PASS" if py_ok else "FAIL"
+    sys.stdout.write(f"[{py_status}] Python Version: {py_ver.major}.{py_ver.minor}.{py_ver.micro} (>= 3.12 required)\n")
+
+    # 2. Git binary check
+    git_bin = shutil.which("git")
+    git_status = "PASS" if git_bin else "WARN"
+    sys.stdout.write(f"[{git_status}] Git Executable: {git_bin or 'Not found in PATH'}\n")
+
+    # 3. Python AST parser check
+    try:
+        symbols, _deps = PythonASTParser.parse_source("test.py", "def hello(): pass")
+        ast_ok = len(symbols) == 1 and symbols[0].name == "hello"
+        ast_status = "PASS" if ast_ok else "FAIL"
+    except Exception as e:
+        ast_status = f"FAIL ({e})"
+    sys.stdout.write(f"[{ast_status}] Python AST Static Analyzer: functional\n")
+
+    # 4. Multi-language TypeScript parser check
+    try:
+        ts_res = JavaScriptTypeScriptParser().parse_source("test.ts", "function greet(): string { return 'hi'; }")
+        ts_ok = len(ts_res.symbols) == 1 and ts_res.symbols[0].name == "greet"
+        ts_status = "PASS" if ts_ok else "FAIL"
+    except Exception as e:
+        ts_status = f"FAIL ({e})"
+    sys.stdout.write(f"[{ts_status}] TypeScript/JavaScript Static Parser: functional\n")
+
+    # 5. External linter (Ruff) check
+    ruff_bin = shutil.which("ruff")
+    ruff_status = "PASS" if ruff_bin else "INFO"
+    sys.stdout.write(f"[{ruff_status}] External Linter (Ruff): {ruff_bin or 'Optional / Not installed'}\n")
+
+    # 6. Service infrastructure status (informational)
+    sys.stdout.write("[INFO] Backend Services (PostgreSQL / Redis): Optional (not required for CLI review)\n")
+    sys.stdout.write("=" * 65 + "\n")
+    sys.stdout.write(f"System diagnostics complete. {__product__} CLI is operational.\n")
+    return 0
+
+
+def build_root_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="logicfalcon",
+        description=f"{__product__} — Fast, precise engineering intelligence. Powered by {__platform__}.",
+    )
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version=f"{__product__} {__version__} (powered by {__platform__})",
+        help="Show program's version number and exit.",
+    )
+
+    subparsers = parser.add_subparsers(dest="subcommand", help="Available subcommands")
+
+    # Subcommand: review
+    subparsers.add_parser(
+        "review",
+        help="Run deterministic repository intelligence & automated code review.",
+        add_help=False,  # Let review parser handle its own flags
+    )
+
+    # Subcommand: doctor
+    subparsers.add_parser(
+        "doctor",
+        help="Run environment health check, AST parser capabilities, and tool diagnostic.",
+    )
+
+    return parser
+
+
+def run_main(args: list[str] | None = None) -> int:
+    argv = sys.argv[1:] if args is None else args
+
+    # Handle direct review fallback when arguments start with review flags
+    if argv and argv[0].startswith("-") and argv[0] not in ("-v", "--version", "-h", "--help"):
+        return run_review_cli(argv)
+
+    if not argv:
+        parser = build_root_parser()
+        parser.print_help()
+        return 0
+
+    if argv[0] in ("-v", "--version"):
+        sys.stdout.write(f"{__product__} {__version__} (powered by {__platform__})\n")
+        return 0
+
+    if argv[0] in ("-h", "--help"):
+        parser = build_root_parser()
+        parser.print_help()
+        return 0
+
+    if argv[0] == "doctor":
+        return run_doctor()
+
+    if argv[0] == "review":
+        return run_review_cli(argv[1:])
+
+    # Fallback to standard argparsing
+    parser = build_root_parser()
+    parsed = parser.parse_args(argv)
+    if parsed.subcommand == "doctor":
+        return run_doctor()
+    elif parsed.subcommand == "review":
+        return run_review_cli(argv[1:])
+
+    parser.print_help()
+    return 0
+
+
+def main() -> NoReturn:
+    sys.exit(run_main())
+
+
+if __name__ == "__main__":
+    main()

logicfalcon/sdk.py

@@ -0,0 +1,166 @@
+"""Programmatic Python SDK for LogicFalcon (Powered by AEGIS AI).
+
+Provides high-level programmatic access for automated code reviews, diff inspections,
+remediation verification, and safe patch applications.
+"""
+
+from pathlib import Path
+
+from packages.review.domain.models import (
+    FindingSeverity,
+    ProposedFix,
+    ReviewFinding,
+    ReviewReport,
+)
+from packages.review.engine import LocalReviewEngine, ReviewConfig
+from packages.review.fix_engine import (
+    FixApplicationResult,
+    RemediationVerificationResult,
+    ReviewFixEngine,
+)
+from packages.review.validator import FindingValidator
+
+__all__ = [
+    "FindingSeverity",
+    "FindingValidator",
+    "FixApplicationResult",
+    "LocalReviewEngine",
+    "ProposedFix",
+    "RemediationVerificationResult",
+    "ReviewConfig",
+    "ReviewFinding",
+    "ReviewFixEngine",
+    "ReviewReport",
+    "apply_fix",
+    "review",
+    "review_diff",
+    "verify_fix",
+]
+
+
+def review(
+    repo: str | Path = ".",
+    base: str | None = None,
+    staged: bool = False,
+    unstaged: bool = False,
+    severity_threshold: str = "ERROR",
+    config: ReviewConfig | None = None,
+) -> ReviewReport:
+    """Executes a code review on a repository or working tree diff.
+
+    Args:
+        repo: Path to target repository root.
+        base: Git commit or branch ref to compare against (e.g. 'origin/main').
+        staged: If True, reviews only staged (cached) Git changes.
+        unstaged: If True, reviews only unstaged working tree changes.
+        severity_threshold: Minimum severity to trigger failure.
+        config: Custom ReviewConfig options.
+
+    Returns:
+        ReviewReport containing findings, affected artifacts, and execution metrics.
+    """
+    repo_path = Path(repo).resolve()
+    engine_config = config or ReviewConfig()
+    engine = LocalReviewEngine(repo_root=repo_path, config=engine_config)
+
+    report = engine.review_local_git_diff(
+        base_ref=base,
+        staged=staged,
+        unstaged=unstaged,
+    )
+
+    validator = FindingValidator(repo_root=repo_path)
+    verified, _ = validator.validate(report.findings)
+    report.findings = verified
+    return report
+
+
+def review_diff(
+    diff_text: str,
+    repo_root: str | Path = ".",
+    config: ReviewConfig | None = None,
+) -> ReviewReport:
+    """Synchronously reviews a raw unified Git diff string.
+
+    Args:
+        diff_text: Unified git diff formatted text.
+        repo_root: Path to repository root for context and validation.
+        config: Custom ReviewConfig options.
+
+    Returns:
+        ReviewReport containing findings and analysis metadata.
+    """
+    repo_path = Path(repo_root).resolve()
+    engine_config = config or ReviewConfig()
+    engine = LocalReviewEngine(repo_root=repo_path, config=engine_config)
+    report = engine.review_diff(diff_text=diff_text)
+
+    diff_summary = engine.diff_parser.parse(diff_text)
+    validator = FindingValidator(repo_root=repo_path)
+    verified, _ = validator.validate(report.findings, diff_summary=diff_summary)
+    report.findings = verified
+    return report
+
+
+def apply_fix(
+    fix: ProposedFix,
+    approved: bool = False,
+    repo_root: str | Path = ".",
+    dry_run: bool = False,
+    validate_syntax: bool = True,
+    create_backup: bool = True,
+) -> FixApplicationResult:
+    """Safely applies a proposed remediation fix to disk.
+
+    Args:
+        fix: ProposedFix object to apply.
+        approved: Explicit developer confirmation (required if dry_run=False).
+        repo_root: Target repository root.
+        dry_run: If True, returns unified diff preview without modifying disk.
+        validate_syntax: If True, checks python syntax before writing.
+        create_backup: If True, creates a .bak copy before modifying.
+
+    Returns:
+        FixApplicationResult with execution status and diff.
+    """
+    repo_path = Path(repo_root).resolve()
+    fix_engine = ReviewFixEngine(repo_root=repo_path)
+    return fix_engine.apply_fix(
+        fix=fix,
+        approved=approved,
+        dry_run=dry_run,
+        validate_syntax=validate_syntax,
+        create_backup=create_backup,
+    )
+
+
+def verify_fix(
+    fixes: list[ProposedFix],
+    repo_root: str | Path = ".",
+    run_tests: bool = True,
+    run_linters: bool = True,
+    test_command: list[str] | None = None,
+    lint_command: list[str] | None = None,
+) -> RemediationVerificationResult:
+    """Applies fixes in an isolated workspace and runs real tests and linters.
+
+    Args:
+        fixes: List of ProposedFix objects to verify.
+        repo_root: Target repository root.
+        run_tests: Whether to execute tests in the isolated workspace.
+        run_linters: Whether to execute linters in the isolated workspace.
+        test_command: Custom test command list (e.g. ['pytest', 'tests/']).
+        lint_command: Custom linter command list (e.g. ['ruff', 'check', '.']).
+
+    Returns:
+        RemediationVerificationResult indicating whether the fix passed QA.
+    """
+    repo_path = Path(repo_root).resolve()
+    fix_engine = ReviewFixEngine(repo_root=repo_path)
+    return fix_engine.verify_remediation(
+        fixes=fixes,
+        run_tests=run_tests,
+        run_linters=run_linters,
+        test_command=test_command,
+        lint_command=lint_command,
+    )