ciforge-cli 0.1.0__tar.gz

ciforge_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ciforge authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ciforge_cli-0.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: ciforge-cli
+Version: 0.1.0
+Summary: A zero-dependency CI tool replacing multiple CI services.
+Keywords: ci,github-actions,code-quality,coverage,linting
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ciforge
+
+**ciforge** is a zero-dependency CLI and GitHub Action that replaces 20 CI services with one robust tool. Run your complete CI pipeline 100% locally or natively within your actions, faster and with zero external dependencies.
+
+## Features
+
+- **Code Quality**: Intelligent linting and complexity analysis without heavy dependencies.
+- **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.
+
+## Installation
+
+```bash
+pip install ciforge
+```
+
+## Usage
+
+Run locally:
+```bash
+ciforge --repo . --base-ref origin/main --format markdown --fail-on high
+```
+
+## GitHub Action Usage
+
+Use `ciforge` directly in your workflows:
+
+```yaml
+steps:
+  - uses: actions/checkout@v3
+  - name: Run ciforge
+    uses: your-org/ciforge@v0.1.0
+    with:
+      repo: '.'
+      base-ref: 'origin/main'
+      format: 'markdown'
+      fail-on: 'high'
+      post-comment: 'true'
+```

ciforge_cli-0.1.0/README.md

@@ -0,0 +1,41 @@
+# ciforge
+
+**ciforge** is a zero-dependency CLI and GitHub Action that replaces 20 CI services with one robust tool. Run your complete CI pipeline 100% locally or natively within your actions, faster and with zero external dependencies.
+
+## Features
+
+- **Code Quality**: Intelligent linting and complexity analysis without heavy dependencies.
+- **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.
+
+## Installation
+
+```bash
+pip install ciforge
+```
+
+## Usage
+
+Run locally:
+```bash
+ciforge --repo . --base-ref origin/main --format markdown --fail-on high
+```
+
+## GitHub Action Usage
+
+Use `ciforge` directly in your workflows:
+
+```yaml
+steps:
+  - uses: actions/checkout@v3
+  - name: Run ciforge
+    uses: your-org/ciforge@v0.1.0
+    with:
+      repo: '.'
+      base-ref: 'origin/main'
+      format: 'markdown'
+      fail-on: 'high'
+      post-comment: 'true'
+```

ciforge_cli-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ciforge-cli"
+version = "0.1.0"
+description = "A zero-dependency CI tool replacing multiple CI services."
+readme = "README.md"
+requires-python = ">=3.8"
+keywords = ["ci", "github-actions", "code-quality", "coverage", "linting"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = []
+
+[project.scripts]
+ciforge = "ciforge.cli:main"

ciforge_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ciforge_cli-0.1.0/src/ciforge/__init__.py

@@ -0,0 +1 @@
+# ciforge

ciforge_cli-0.1.0/src/ciforge/cli.py

@@ -0,0 +1,45 @@
+import argparse
+import sys
+from . import scanner, code_quality, secrets, config_validator, coverage
+
+SEVERITY_LEVELS = {'low': 0, 'medium': 1, 'high': 2, 'critical': 3}
+
+def main():
+    parser = argparse.ArgumentParser(description="ciforge CLI")
+    parser.add_argument('--fail-on', type=str, default='high', choices=['low', 'medium', 'high', 'critical', 'none'], help='Exit non-zero if findings of this severity or higher are found')
+    args = parser.parse_args()
+
+    files = scanner.git_changed_files()
+    all_findings = []
+
+    for f in files:
+        diff_text = scanner.git_diff(f)
+        all_findings.extend(code_quality.analyze(f, diff_text))
+        all_findings.extend(secrets.analyze(f, diff_text))
+        all_findings.extend(config_validator.analyze(f, diff_text))
+
+    all_findings.extend(coverage.analyze())
+
+    if not all_findings:
+        print("No issues found. Great job!")
+        sys.exit(0)
+
+    print("# ciforge Report\n")
+    max_severity_found = -1
+    
+    for finding in all_findings:
+        sev_val = SEVERITY_LEVELS.get(finding.severity, 0)
+        max_severity_found = max(max_severity_found, sev_val)
+        line_info = f":{finding.line}" if finding.line > 0 else ""
+        print(f"- **[{finding.severity.upper()}]** `{finding.file}{line_info}`: {finding.message}")
+
+    if args.fail_on != 'none':
+        fail_threshold = SEVERITY_LEVELS.get(args.fail_on, 3)
+        if max_severity_found >= fail_threshold:
+            print(f"\nFailed: Found issues with severity '{args.fail_on}' or higher.")
+            sys.exit(1)
+
+    sys.exit(0)
+
+if __name__ == '__main__':
+    main()

ciforge_cli-0.1.0/src/ciforge/code_quality.py

@@ -0,0 +1,36 @@
+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/src/ciforge/config_validator.py

@@ -0,0 +1,33 @@
+import json
+import re
+from typing import List
+from .scanner import Finding, git_diff, _extract_diff_sections
+
+def analyze(file_path: str, diff_text: str = None) -> List[Finding]:
+    findings = []
+    
+    if diff_text is None:
+        diff_text = git_diff(file_path)
+        
+    added_lines = _extract_diff_sections(diff_text)
+    
+    if file_path.endswith('.env') and not file_path.endswith('.env.example'):
+        if added_lines:
+            findings.append(Finding(file_path, 0, ".env file added to diff", "high"))
+            
+    if file_path.endswith('.json'):
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            json.loads(content)
+        except json.JSONDecodeError as e:
+            findings.append(Finding(file_path, getattr(e, 'lineno', 0), f"Invalid JSON: {str(e)}", "high"))
+        except FileNotFoundError:
+            pass
+
+    if file_path.endswith('.yaml') or file_path.endswith('.yml'):
+        for line_num, line_content in added_lines:
+            if re.search(r'^\s*\t', line_content) or '\t' in line_content:
+                findings.append(Finding(file_path, line_num, "YAML file indented with tabs", "medium"))
+                
+    return findings

ciforge_cli-0.1.0/src/ciforge/coverage.py

@@ -0,0 +1,20 @@
+import json
+import os
+from typing import List
+from .scanner import Finding
+
+def analyze(repo_root: str = ".") -> List[Finding]:
+    findings = []
+    coverage_file = os.path.join(repo_root, ".ciforge-coverage.json")
+    
+    if os.path.exists(coverage_file):
+        try:
+            with open(coverage_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                cov = data.get('coverage', 100.0)
+                if cov < 80.0:
+                    findings.append(Finding(coverage_file, 0, f"Code coverage too low: {cov}% (< 80%)", "medium"))
+        except (json.JSONDecodeError, ValueError):
+            findings.append(Finding(coverage_file, 0, "Invalid coverage file format", "medium"))
+            
+    return findings

ciforge_cli-0.1.0/src/ciforge/scanner.py

@@ -0,0 +1,64 @@
+import subprocess
+from dataclasses import dataclass
+from typing import List, Tuple
+
+@dataclass
+class Finding:
+    file: str
+    line: int
+    message: str
+    severity: str
+
+def git_changed_files() -> List[str]:
+    try:
+        # Check if we are in a git repo
+        subprocess.run(["git", "rev-parse", "--is-inside-work-tree"], capture_output=True, check=True)
+        # Get changed files (staged and unstaged) compared to HEAD, or just all tracked/untracked for simplicity in tests
+        # To avoid issues with fresh git repos, we can just look at status
+        result = subprocess.run(["git", "diff", "--name-only", "HEAD"], capture_output=True, text=True)
+        if result.returncode != 0:
+            result = subprocess.run(["git", "ls-files"], capture_output=True, text=True, check=True)
+        return [line for line in result.stdout.splitlines() if line.strip()]
+    except Exception:
+        return []
+
+def git_diff(file_path: str) -> str:
+    try:
+        result = subprocess.run(["git", "diff", "HEAD", "--", file_path], capture_output=True, text=True)
+        if result.returncode != 0 or not result.stdout.strip():
+            # If no HEAD, try `git diff --no-index /dev/null file_path` or similar
+            # Since we only care about added lines for new files or diffs
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            # Fake a diff for newly added files
+            diff = f"--- /dev/null\n+++ b/{file_path}\n@@ -0,0 +1,{len(content.splitlines())} @@\n"
+            for line in content.splitlines():
+                diff += f"+{line}\n"
+            return diff
+        return result.stdout
+    except Exception:
+        return ""
+
+def _extract_diff_sections(diff_text: str) -> List[Tuple[int, str]]:
+    added_lines = []
+    current_line = 0
+    
+    for line in diff_text.splitlines():
+        if line.startswith('@@'):
+            parts = line.split()
+            if len(parts) >= 3:
+                new_hunk = parts[2]
+                if new_hunk.startswith('+'):
+                    new_hunk = new_hunk[1:]
+                    new_start = new_hunk.split(',')[0]
+                    current_line = int(new_start) - 1
+        elif line.startswith('+') and not line.startswith('+++'):
+            current_line += 1
+            added_lines.append((current_line, line[1:]))
+        elif line.startswith('-') and not line.startswith('---'):
+            pass
+        elif not line.startswith('\\'):
+            if current_line > 0:
+                current_line += 1
+                
+    return added_lines

ciforge_cli-0.1.0/src/ciforge/secrets.py

@@ -0,0 +1,23 @@
+import re
+from typing import List
+from .scanner import Finding, _extract_diff_sections, git_diff
+
+PATTERNS = {
+    'aws_key': re.compile(r'(?i)AKIA[0-9A-Z]{16}'),
+    'github_token': re.compile(r'(ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{36}'),
+    'generic_secret': re.compile(r'(?i)(password|secret|api[_-]?key|token)\s*[:=]\s*[\'\"][A-Za-z0-9_\-]{8,}[\'\"]')
+}
+
+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)
+    
+    for line_num, line_content in added_lines:
+        for secret_type, pattern in PATTERNS.items():
+            if pattern.search(line_content):
+                findings.append(Finding(file_path, line_num, f"Leaked secret detected ({secret_type})", "critical"))
+                
+    return findings

ciforge_cli-0.1.0/src/ciforge_cli.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: ciforge-cli
+Version: 0.1.0
+Summary: A zero-dependency CI tool replacing multiple CI services.
+Keywords: ci,github-actions,code-quality,coverage,linting
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ciforge
+
+**ciforge** is a zero-dependency CLI and GitHub Action that replaces 20 CI services with one robust tool. Run your complete CI pipeline 100% locally or natively within your actions, faster and with zero external dependencies.
+
+## Features
+
+- **Code Quality**: Intelligent linting and complexity analysis without heavy dependencies.
+- **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.
+
+## Installation
+
+```bash
+pip install ciforge
+```
+
+## Usage
+
+Run locally:
+```bash
+ciforge --repo . --base-ref origin/main --format markdown --fail-on high
+```
+
+## GitHub Action Usage
+
+Use `ciforge` directly in your workflows:
+
+```yaml
+steps:
+  - uses: actions/checkout@v3
+  - name: Run ciforge
+    uses: your-org/ciforge@v0.1.0
+    with:
+      repo: '.'
+      base-ref: 'origin/main'
+      format: 'markdown'
+      fail-on: 'high'
+      post-comment: 'true'
+```

ciforge_cli-0.1.0/src/ciforge_cli.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/ciforge/__init__.py
+src/ciforge/cli.py
+src/ciforge/code_quality.py
+src/ciforge/config_validator.py
+src/ciforge/coverage.py
+src/ciforge/scanner.py
+src/ciforge/secrets.py
+src/ciforge_cli.egg-info/PKG-INFO
+src/ciforge_cli.egg-info/SOURCES.txt
+src/ciforge_cli.egg-info/dependency_links.txt
+src/ciforge_cli.egg-info/entry_points.txt
+src/ciforge_cli.egg-info/top_level.txt
+tests/test_ciforge.py

ciforge_cli-0.1.0/src/ciforge_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ciforge_cli-0.1.0/src/ciforge_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ciforge = ciforge.cli:main

ciforge_cli-0.1.0/src/ciforge_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+ciforge

ciforge_cli-0.1.0/tests/test_ciforge.py

@@ -0,0 +1,70 @@
+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()