ciforge-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{ciforge_cli-0.1.0 → ciforge_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ciforge-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: A zero-dependency CI tool replacing multiple CI services.
 Keywords: ci,github-actions,code-quality,coverage,linting
 Classifier: Development Status :: 3 - Alpha
@@ -23,11 +23,14 @@ Dynamic: license-file
 
 ## Features
 
-- **Code Quality**: Intelligent linting and complexity analysis without heavy dependencies.
+- **Code Quality**: Intelligent linting and AST-based complexity analysis (cyclomatic complexity, long functions).
 - **Test Coverage Analysis**: Deep inspection of test coverage gaps.
 - **Secret Detection**: Catch hardcoded credentials before they reach your repository.
 - **Config Validation**: Ensure your CI/CD and infrastructure configuration files are sound.
-- **PR Metrics**: Analyze pull request size, churn, and impact metrics.
+- **PR Metrics & Velocity Tracking**: Analyze pull request size, churn, and time span metrics.
+- **AI Reviewer**: Integrates with OpenAI to automatically find logic flaws and missing edge cases.
+- **Image Optimization**: Detects large unoptimized assets (.png, .jpg, .jpeg) over 500KB.
+- **Localization Sync**: Finds missing translation keys by comparing localization files against a base en.json.
 
 ## Installation
 

{ciforge_cli-0.1.0 → ciforge_cli-0.2.0}/README.md

@@ -4,11 +4,14 @@
 
 ## Features
 
-- **Code Quality**: Intelligent linting and complexity analysis without heavy dependencies.
+- **Code Quality**: Intelligent linting and AST-based complexity analysis (cyclomatic complexity, long functions).
 - **Test Coverage Analysis**: Deep inspection of test coverage gaps.
 - **Secret Detection**: Catch hardcoded credentials before they reach your repository.
 - **Config Validation**: Ensure your CI/CD and infrastructure configuration files are sound.
-- **PR Metrics**: Analyze pull request size, churn, and impact metrics.
+- **PR Metrics & Velocity Tracking**: Analyze pull request size, churn, and time span metrics.
+- **AI Reviewer**: Integrates with OpenAI to automatically find logic flaws and missing edge cases.
+- **Image Optimization**: Detects large unoptimized assets (.png, .jpg, .jpeg) over 500KB.
+- **Localization Sync**: Finds missing translation keys by comparing localization files against a base en.json.
 
 ## Installation
 

{ciforge_cli-0.1.0 → ciforge_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ciforge-cli"
-version = "0.1.0"
+version = "0.2.0"
 description = "A zero-dependency CI tool replacing multiple CI services."
 readme = "README.md"
 requires-python = ">=3.8"

ciforge_cli-0.2.0/src/ciforge/ai_reviewer.py

@@ -0,0 +1,50 @@
+import os
+import json
+import urllib.request
+from typing import List
+from .scanner import Finding, git_changed_files, git_diff
+
+def analyze() -> List[Finding]:
+    api_key = os.environ.get("CIFORGE_AI_KEY")
+    if not api_key:
+        return []
+
+    files = git_changed_files()
+    diffs = []
+    for f in files:
+        diff_text = git_diff(f)
+        if diff_text:
+            diffs.append(f"File: {f}\n{diff_text}")
+    
+    if not diffs:
+        return []
+
+    full_diff = "\n\n".join(diffs)
+    
+    # We don't want to send huge diffs to API, but for this mock/simple implementation we do.
+    prompt = "Review the following code diff and identify logic flaws or missing edge cases. Provide a brief summary.\n\n" + full_diff
+
+    req_data = json.dumps({
+        "model": "gpt-3.5-turbo",
+        "messages": [
+            {"role": "system", "content": "You are a code reviewer."},
+            {"role": "user", "content": prompt}
+        ]
+    }).encode("utf-8")
+
+    req = urllib.request.Request(
+        "https://api.openai.com/v1/chat/completions",
+        data=req_data,
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}"
+        }
+    )
+
+    try:
+        with urllib.request.urlopen(req) as response:
+            result = json.loads(response.read().decode("utf-8"))
+            summary = result["choices"][0]["message"]["content"]
+            return [Finding("AI_Review", 0, f"AI Reviewer: {summary}", "medium")]
+    except Exception as e:
+        return [Finding("AI_Review", 0, f"AI Reviewer failed: {e}", "low")]

ciforge_cli-0.2.0/src/ciforge/assets.py

@@ -0,0 +1,25 @@
+import os
+from typing import List
+from .scanner import Finding
+
+def analyze() -> List[Finding]:
+    findings = []
+    # Analyze the repository files for large images
+    for root, _, files in os.walk('.'):
+        if '.git' in root:
+            continue
+        for file in files:
+            if file.lower().endswith(('.png', '.jpg', '.jpeg')):
+                file_path = os.path.join(root, file)
+                try:
+                    size = os.path.getsize(file_path)
+                    if size > 500 * 1024:
+                        findings.append(Finding(
+                            file=file_path,
+                            line=0,
+                            message=f"Unoptimized asset: {file} is {size / (1024 * 1024):.2f}MB. Compress it.",
+                            severity="high"
+                        ))
+                except Exception:
+                    pass
+    return findings

{ciforge_cli-0.1.0 → ciforge_cli-0.2.0}/src/ciforge/cli.py

@@ -1,6 +1,6 @@
 import argparse
 import sys
-from . import scanner, code_quality, secrets, config_validator, coverage
+from . import scanner, code_quality, secrets, config_validator, coverage, ai_reviewer, assets, l10n, metrics
 
 SEVERITY_LEVELS = {'low': 0, 'medium': 1, 'high': 2, 'critical': 3}
 
@@ -19,6 +19,10 @@ def main():
         all_findings.extend(config_validator.analyze(f, diff_text))
 
     all_findings.extend(coverage.analyze())
+    all_findings.extend(ai_reviewer.analyze())
+    all_findings.extend(assets.analyze())
+    all_findings.extend(l10n.analyze())
+    all_findings.extend(metrics.analyze())
 
     if not all_findings:
         print("No issues found. Great job!")

ciforge_cli-0.2.0/src/ciforge/code_quality.py

@@ -0,0 +1,64 @@
+import re
+import ast
+import os
+from typing import List
+from .scanner import Finding, _extract_diff_sections, git_diff
+
+def analyze(file_path: str, diff_text: str = None) -> List[Finding]:
+    if diff_text is None:
+        diff_text = git_diff(file_path)
+        
+    findings = []
+    added_lines = _extract_diff_sections(diff_text)
+    
+    contiguous_count = 0
+    contiguous_start_line = 0
+    
+    for line_num, line_content in added_lines:
+        # Check for TODO / FIXME / HACK
+        match = re.search(r'\b(TODO|FIXME|HACK)\b', line_content)
+        if match:
+            findings.append(Finding(file_path, line_num, f"Found {match.group(1)}", "medium"))
+            
+        # Check for console.log, print(), debugger
+        if re.search(r'\b(console\.log|print\s*\(|debugger\b)', line_content):
+            findings.append(Finding(file_path, line_num, "Found debug statement", "medium"))
+            
+        # Very large function primitive check
+        if line_content.strip() == '':
+            contiguous_count = 0
+        else:
+            if contiguous_count == 0:
+                contiguous_start_line = line_num
+            contiguous_count += 1
+            
+            if contiguous_count == 51:
+                findings.append(Finding(file_path, contiguous_start_line, "Very large function/block detected (>50 lines)", "low"))
+                
+    # AST analysis for python files
+    if file_path.endswith('.py') and os.path.exists(file_path):
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                tree = ast.parse(f.read(), filename=file_path)
+                
+            for node in ast.walk(tree):
+                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    # Cyclomatic complexity
+                    complexity = 1
+                    for child in ast.walk(node):
+                        if isinstance(child, (ast.If, ast.For, ast.While, ast.Try, ast.ExceptHandler, ast.With, ast.AsyncFor, ast.AsyncWith)):
+                            complexity += 1
+                        elif isinstance(child, ast.BoolOp):
+                            complexity += len(child.values) - 1
+                            
+                    if complexity > 10:
+                        findings.append(Finding(file_path, getattr(node, 'lineno', 0), f"High cyclomatic complexity: {complexity} (>10)", "high"))
+                        
+                    # Long function check
+                    if hasattr(node, 'end_lineno') and hasattr(node, 'lineno'):
+                        if node.end_lineno - node.lineno > 50:
+                            findings.append(Finding(file_path, node.lineno, f"Long function: {node.name} is {node.end_lineno - node.lineno} lines (>50)", "high"))
+        except Exception:
+            pass
+
+    return findings

ciforge_cli-0.2.0/src/ciforge/l10n.py

@@ -0,0 +1,39 @@
+import os
+import json
+from typing import List
+from .scanner import Finding
+
+def analyze() -> List[Finding]:
+    findings = []
+    
+    # Scan repo for localization files. Pick en.json as base.
+    for root, _, files in os.walk('.'):
+        if '.git' in root:
+            continue
+            
+        if 'en.json' in files:
+            en_path = os.path.join(root, 'en.json')
+            try:
+                with open(en_path, 'r', encoding='utf-8') as f:
+                    en_data = json.load(f)
+                    en_keys = set(en_data.keys())
+                    
+                for file in files:
+                    if file.endswith('.json') and file != 'en.json':
+                        file_path = os.path.join(root, file)
+                        with open(file_path, 'r', encoding='utf-8') as f:
+                            data = json.load(f)
+                            keys = set(data.keys())
+                            
+                        missing = en_keys - keys
+                        for key in missing:
+                            findings.append(Finding(
+                                file=file_path,
+                                line=0,
+                                message=f"Missing translation key: '{key}'",
+                                severity="medium"
+                            ))
+            except Exception:
+                pass
+                
+    return findings

ciforge_cli-0.2.0/src/ciforge/metrics.py

@@ -0,0 +1,26 @@
+import subprocess
+from typing import List
+from .scanner import Finding
+
+def analyze() -> List[Finding]:
+    findings = []
+    try:
+        # Get commit timestamps
+        result = subprocess.run(["git", "log", "--format=%ct", "--reverse"], capture_output=True, text=True)
+        if result.returncode == 0:
+            lines = result.stdout.splitlines()
+            if len(lines) >= 2:
+                first_commit = int(lines[0])
+                last_commit = int(lines[-1])
+                diff_seconds = last_commit - first_commit
+                hours = diff_seconds / 3600
+                findings.append(Finding(
+                    file="Git Metrics",
+                    line=0,
+                    message=f"Velocity Report: Branch active for {hours:.1f} hours over {len(lines)} commits.",
+                    severity="low"
+                ))
+    except Exception:
+        pass
+        
+    return findings

{ciforge_cli-0.1.0 → ciforge_cli-0.2.0}/src/ciforge_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ciforge-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: A zero-dependency CI tool replacing multiple CI services.
 Keywords: ci,github-actions,code-quality,coverage,linting
 Classifier: Development Status :: 3 - Alpha
@@ -23,11 +23,14 @@ Dynamic: license-file
 
 ## Features
 
-- **Code Quality**: Intelligent linting and complexity analysis without heavy dependencies.
+- **Code Quality**: Intelligent linting and AST-based complexity analysis (cyclomatic complexity, long functions).
 - **Test Coverage Analysis**: Deep inspection of test coverage gaps.
 - **Secret Detection**: Catch hardcoded credentials before they reach your repository.
 - **Config Validation**: Ensure your CI/CD and infrastructure configuration files are sound.
-- **PR Metrics**: Analyze pull request size, churn, and impact metrics.
+- **PR Metrics & Velocity Tracking**: Analyze pull request size, churn, and time span metrics.
+- **AI Reviewer**: Integrates with OpenAI to automatically find logic flaws and missing edge cases.
+- **Image Optimization**: Detects large unoptimized assets (.png, .jpg, .jpeg) over 500KB.
+- **Localization Sync**: Finds missing translation keys by comparing localization files against a base en.json.
 
 ## Installation
 

{ciforge_cli-0.1.0 → ciforge_cli-0.2.0}/src/ciforge_cli.egg-info/SOURCES.txt

@@ -2,10 +2,14 @@ LICENSE
 README.md
 pyproject.toml
 src/ciforge/__init__.py
+src/ciforge/ai_reviewer.py
+src/ciforge/assets.py
 src/ciforge/cli.py
 src/ciforge/code_quality.py
 src/ciforge/config_validator.py
 src/ciforge/coverage.py
+src/ciforge/l10n.py
+src/ciforge/metrics.py
 src/ciforge/scanner.py
 src/ciforge/secrets.py
 src/ciforge_cli.egg-info/PKG-INFO

ciforge_cli-0.2.0/tests/test_ciforge.py

@@ -0,0 +1,122 @@
+import unittest
+from unittest.mock import patch, mock_open
+
+from src.ciforge.scanner import Finding, _extract_diff_sections
+from src.ciforge import code_quality, secrets, config_validator, coverage, ai_reviewer, assets, l10n, metrics
+
+class TestCiforge(unittest.TestCase):
+
+    def test_extract_diff_sections(self):
+        diff = """--- a/file.py
++++ b/file.py
+@@ -10,3 +10,4 @@
+ def func():
+-    pass
++    print('hello')
++    return True
+"""
+        added = _extract_diff_sections(diff)
+        self.assertEqual(added, [(11, "    print('hello')"), (12, "    return True")])
+
+    def test_code_quality(self):
+        diff = "@@ -0,0 +1,55 @@\n+def large_func():\n" + "+    pass\n" * 50
+        findings = code_quality.analyze("file.py", diff)
+        self.assertTrue(any("Very large function" in f.message for f in findings))
+        self.assertTrue(any(f.severity == "low" for f in findings))
+
+        diff = "@@ -0,0 +1,2 @@\n+# TODO: fix this\n+console.log('test')\n"
+        findings = code_quality.analyze("file.js", diff)
+        self.assertEqual(len(findings), 2)
+        self.assertEqual(findings[0].message, "Found TODO")
+        self.assertEqual(findings[1].message, "Found debug statement")
+
+    def test_secrets(self):
+        fake_aws = "AKIA" + "IOSFODNN7EXAMPLE"
+        diff = f"@@ -0,0 +1,1 @@\n+my_var = '{fake_aws}'\n"
+        findings = secrets.analyze("config.py", diff)
+        self.assertEqual(len(findings), 1)
+        self.assertTrue("aws_key" in findings[0].message)
+        self.assertEqual(findings[0].severity, "critical")
+
+        fake_gh = "ghp_" + "123456789012345678901234567890123456"
+        diff2 = f"@@ -0,0 +1,1 @@\n+my_token_var = '{fake_gh}'\n"
+        findings2 = secrets.analyze("auth.py", diff2)
+        self.assertEqual(len(findings2), 1)
+        self.assertTrue("github_token" in findings2[0].message)
+
+    def test_config_validator_env(self):
+        diff = "@@ -0,0 +1,1 @@\n+SECRET=123\n"
+        findings = config_validator.analyze(".env", diff)
+        self.assertEqual(len(findings), 1)
+        self.assertEqual(findings[0].severity, "high")
+        
+        findings2 = config_validator.analyze(".env.example", diff)
+        self.assertEqual(len(findings2), 0)
+
+    def test_config_validator_yaml(self):
+        diff = "@@ -0,0 +1,1 @@\n+\tkey: value\n"
+        findings = config_validator.analyze("config.yml", diff)
+        self.assertEqual(len(findings), 1)
+        self.assertTrue("tabs" in findings[0].message)
+        self.assertEqual(findings[0].severity, "medium")
+
+    @patch("os.path.exists", return_value=True)
+    def test_coverage(self, mock_exists):
+        with patch("builtins.open", mock_open(read_data='{"coverage": 75.0}')):
+            findings = coverage.analyze()
+            self.assertEqual(len(findings), 1)
+            self.assertTrue("Code coverage too low" in findings[0].message)
+            self.assertEqual(findings[0].severity, "medium")
+
+    @patch("os.environ.get", return_value="dummy_key")
+    @patch("src.ciforge.ai_reviewer.git_changed_files", return_value=["test.py"])
+    @patch("src.ciforge.ai_reviewer.git_diff", return_value="+print('test')")
+    @patch("urllib.request.urlopen")
+    def test_ai_reviewer(self, mock_urlopen, mock_git_diff, mock_git_files, mock_env):
+        from io import BytesIO
+        import json
+        mock_response = BytesIO(json.dumps({"choices": [{"message": {"content": "Looks good"}}]}).encode("utf-8"))
+        mock_urlopen.return_value.__enter__.return_value = mock_response
+        findings = ai_reviewer.analyze()
+        self.assertEqual(len(findings), 1)
+        self.assertTrue("Looks good" in findings[0].message)
+
+    @patch("os.walk")
+    @patch("os.path.getsize", return_value=600 * 1024)
+    def test_assets(self, mock_getsize, mock_walk):
+        mock_walk.return_value = [(".", [], ["large_image.png"])]
+        findings = assets.analyze()
+        self.assertEqual(len(findings), 1)
+        self.assertTrue("Unoptimized asset" in findings[0].message)
+
+    @patch("os.walk")
+    @patch("builtins.open", new_callable=mock_open)
+    def test_l10n(self, mock_open_file, mock_walk):
+        mock_walk.return_value = [(".", [], ["en.json", "fr.json"])]
+        def side_effect(filename, *args, **kwargs):
+            if "en.json" in filename:
+                return mock_open(read_data='{"hello": "world", "test": "1"}').return_value
+            else:
+                return mock_open(read_data='{"hello": "monde"}').return_value
+        mock_open_file.side_effect = side_effect
+        findings = l10n.analyze()
+        self.assertEqual(len(findings), 1)
+        self.assertTrue("Missing translation key: 'test'" in findings[0].message)
+
+    @patch("subprocess.run")
+    def test_metrics(self, mock_run):
+        mock_run.return_value.returncode = 0
+        mock_run.return_value.stdout = "1000\n2000\n5600"
+        findings = metrics.analyze()
+        self.assertEqual(len(findings), 1)
+        self.assertTrue("Velocity Report" in findings[0].message)
+
+    @patch("os.path.exists", return_value=True)
+    def test_code_quality_ast(self, mock_exists):
+        python_code = "def complex_func():\n" + "".join([f"    if True:\n        pass\n" for _ in range(11)])
+        with patch("builtins.open", mock_open(read_data=python_code)):
+            findings = code_quality.analyze("file.py", "+def complex_func():")
+            self.assertTrue(any("High cyclomatic complexity" in f.message for f in findings))
+
+if __name__ == '__main__':
+    unittest.main()

ciforge_cli-0.1.0/src/ciforge/code_quality.py

@@ -1,36 +0,0 @@
-import re
-from typing import List
-from .scanner import Finding, _extract_diff_sections, git_diff
-
-def analyze(file_path: str, diff_text: str = None) -> List[Finding]:
-    if diff_text is None:
-        diff_text = git_diff(file_path)
-        
-    findings = []
-    added_lines = _extract_diff_sections(diff_text)
-    
-    contiguous_count = 0
-    contiguous_start_line = 0
-    
-    for line_num, line_content in added_lines:
-        # Check for TODO / FIXME / HACK
-        match = re.search(r'\b(TODO|FIXME|HACK)\b', line_content)
-        if match:
-            findings.append(Finding(file_path, line_num, f"Found {match.group(1)}", "medium"))
-            
-        # Check for console.log, print(), debugger
-        if re.search(r'\b(console\.log|print\s*\(|debugger\b)', line_content):
-            findings.append(Finding(file_path, line_num, "Found debug statement", "medium"))
-            
-        # Very large function primitive check
-        if line_content.strip() == '':
-            contiguous_count = 0
-        else:
-            if contiguous_count == 0:
-                contiguous_start_line = line_num
-            contiguous_count += 1
-            
-            if contiguous_count == 51:
-                findings.append(Finding(file_path, contiguous_start_line, "Very large function/block detected (>50 lines)", "low"))
-                
-    return findings

ciforge_cli-0.1.0/tests/test_ciforge.py

@@ -1,70 +0,0 @@
-import unittest
-from unittest.mock import patch, mock_open
-
-from src.ciforge.scanner import Finding, _extract_diff_sections
-from src.ciforge import code_quality, secrets, config_validator, coverage
-
-class TestCiforge(unittest.TestCase):
-
-    def test_extract_diff_sections(self):
-        diff = """--- a/file.py
-+++ b/file.py
-@@ -10,3 +10,4 @@
- def func():
--    pass
-+    print('hello')
-+    return True
-"""
-        added = _extract_diff_sections(diff)
-        self.assertEqual(added, [(11, "    print('hello')"), (12, "    return True")])
-
-    def test_code_quality(self):
-        diff = "@@ -0,0 +1,55 @@\n+def large_func():\n" + "+    pass\n" * 50
-        findings = code_quality.analyze("file.py", diff)
-        self.assertTrue(any("Very large function" in f.message for f in findings))
-        self.assertTrue(any(f.severity == "low" for f in findings))
-
-        diff = "@@ -0,0 +1,2 @@\n+# TODO: fix this\n+console.log('test')\n"
-        findings = code_quality.analyze("file.js", diff)
-        self.assertEqual(len(findings), 2)
-        self.assertEqual(findings[0].message, "Found TODO")
-        self.assertEqual(findings[1].message, "Found debug statement")
-
-    def test_secrets(self):
-        diff = "@@ -0,0 +1,1 @@\n+my_var = 'AKIAIOSFODNN7EXAMPLE'\n"
-        findings = secrets.analyze("config.py", diff)
-        self.assertEqual(len(findings), 1)
-        self.assertTrue("aws_key" in findings[0].message)
-        self.assertEqual(findings[0].severity, "critical")
-
-        diff2 = "@@ -0,0 +1,1 @@\n+my_token_var = 'ghp_123456789012345678901234567890123456'\n"
-        findings2 = secrets.analyze("auth.py", diff2)
-        self.assertEqual(len(findings2), 1)
-        self.assertTrue("github_token" in findings2[0].message)
-
-    def test_config_validator_env(self):
-        diff = "@@ -0,0 +1,1 @@\n+SECRET=123\n"
-        findings = config_validator.analyze(".env", diff)
-        self.assertEqual(len(findings), 1)
-        self.assertEqual(findings[0].severity, "high")
-        
-        findings2 = config_validator.analyze(".env.example", diff)
-        self.assertEqual(len(findings2), 0)
-
-    def test_config_validator_yaml(self):
-        diff = "@@ -0,0 +1,1 @@\n+\tkey: value\n"
-        findings = config_validator.analyze("config.yml", diff)
-        self.assertEqual(len(findings), 1)
-        self.assertTrue("tabs" in findings[0].message)
-        self.assertEqual(findings[0].severity, "medium")
-
-    @patch("os.path.exists", return_value=True)
-    def test_coverage(self, mock_exists):
-        with patch("builtins.open", mock_open(read_data='{"coverage": 75.0}')):
-            findings = coverage.analyze()
-            self.assertEqual(len(findings), 1)
-            self.assertTrue("Code coverage too low" in findings[0].message)
-            self.assertEqual(findings[0].severity, "medium")
-
-if __name__ == '__main__':
-    unittest.main()