propre-cli 0.1.0__tar.gz

propre_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 immerSIR
+
+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.

propre_cli-0.1.0/PKG-INFO

@@ -0,0 +1,211 @@
+Metadata-Version: 2.4
+Name: propre-cli
+Version: 0.1.0
+Summary: Analyze, restructure, and harden vibe-coded projects for production. Architecture-level linting, secret detection, and code quality enforcement in one CLI.
+Author-email: immerSIR <immersir223@gmail.com>
+Maintainer-email: immerSIR <immersir223@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/immerSIR/propre-cli
+Project-URL: Documentation, https://github.com/immerSIR/propre-cli#readme
+Project-URL: Repository, https://github.com/immerSIR/propre-cli
+Project-URL: Issues, https://github.com/immerSIR/propre-cli/issues
+Project-URL: Changelog, https://github.com/immerSIR/propre-cli/blob/main/CHANGELOG.md
+Keywords: cli,code-quality,security,secret-detection,refactoring,restructuring,developer-tools,architecture,linting,production-readiness,vibe-coding
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: rich>=13.7.1
+Requires-Dist: typer>=0.12.5
+Provides-Extra: parsers
+Requires-Dist: tree-sitter>=0.22.3; extra == "parsers"
+Requires-Dist: tree-sitter-languages>=1.10.2; extra == "parsers"
+Dynamic: license-file
+
+# Propre
+
+**Propre** is a post-vibe-coding cleanup and hardening CLI.
+
+It analyzes AI-generated or rapidly prototyped codebases and prepares them for real-world use by detecting structural issues, unsafe patterns, and production blockers — then optionally fixing them.
+
+> From messy prototype → production-ready project.
+
+---
+
+## Installation
+
+```bash
+pip install propre
+```
+
+---
+
+## Quick Start
+
+Analyze a project:
+
+```bash
+propre scan .
+```
+
+Auto-fix safe issues:
+
+```bash
+propre fix .
+```
+
+Check production readiness:
+
+```bash
+propre ship .
+```
+
+Generate a report:
+
+```bash
+propre report . -o report.md
+```
+
+---
+
+## Commands
+
+| Command                        | Description                    |
+| ------------------------------ | ------------------------------ |
+| `propre scan [path]`           | Full analysis (no changes)     |
+| `propre fix [path]`            | Auto-fix safe issues           |
+| `propre res [path]`            | Project restructuring only     |
+| `propre sec [path]`            | Secret scanning only           |
+| `propre ship [path]`           | Production readiness checklist |
+| `propre report [path] -o file` | Export full report             |
+
+
+---
+
+## Common Workflows
+
+### Before committing AI-generated code
+
+```bash
+propre scan .
+```
+
+### Before opening a pull request
+
+```bash
+propre fix .
+propre ship .
+```
+
+### CI safety check
+
+```bash
+propre scan . --ci
+```
+
+### Security audit
+
+```bash
+propre sec . --deep-scan
+```
+
+---
+
+## Global Flags
+
+| Flag                  | Description                            |      |        |               |
+| --------------------- | -------------------------------------- | ---- | ------ | ------------- |
+| `--dry-run`           | Preview changes without applying       |      |        |               |
+| `--verbose` / `-v`    | Detailed output                        |      |        |               |
+| `--config propre.yml` | Custom rules                           |      |        |               |
+| `--fix`               | Apply safe fixes outside `fix` command |      |        |               |
+| `--ignore <pattern>`  | Exclude paths                          |      |        |               |
+| `--ci`                | Exit non-zero if blockers found        |      |        |               |
+| `--format terminal    | md                                     | json | sarif` | Output format |
+
+---
+
+## Configuration
+
+Create a `propre.yml` at your project root:
+
+```yaml
+stack: auto
+
+restructure:
+    enabled: true
+    confirm: true
+
+secrets:
+    deep_scan: false
+    severity_threshold: medium
+
+rules:
+    dead_code: warn
+    console_logs: error
+    missing_types: warn
+    hardcoded_config: error
+
+ignore:
+    - node_modules/
+    - .git/
+    - dist/
+```
+
+---
+
+## What Propre Detects
+
+- Dead code & unused files
+- Debug logs & leftover prints
+- Missing typing
+- Hardcoded configuration
+- Project structure issues
+- Secrets & credentials
+- Production blockers
+
+---
+
+## CI Integration
+
+Example GitHub Action step:
+
+```bash
+propre scan . --ci
+```
+
+The command exits with a non-zero code if blocking issues are found.
+
+---
+
+## Philosophy
+
+Modern coding workflows generate code faster than they validate it.
+
+Propre acts as the **final safety layer** between experimentation and deployment:
+
+- AI coding assistants create
+- Developers iterate
+- **Propre hardens**
+
+---
+
+## License
+
+MIT
+
+---

propre_cli-0.1.0/README.md

@@ -0,0 +1,173 @@
+# Propre
+
+**Propre** is a post-vibe-coding cleanup and hardening CLI.
+
+It analyzes AI-generated or rapidly prototyped codebases and prepares them for real-world use by detecting structural issues, unsafe patterns, and production blockers — then optionally fixing them.
+
+> From messy prototype → production-ready project.
+
+---
+
+## Installation
+
+```bash
+pip install propre
+```
+
+---
+
+## Quick Start
+
+Analyze a project:
+
+```bash
+propre scan .
+```
+
+Auto-fix safe issues:
+
+```bash
+propre fix .
+```
+
+Check production readiness:
+
+```bash
+propre ship .
+```
+
+Generate a report:
+
+```bash
+propre report . -o report.md
+```
+
+---
+
+## Commands
+
+| Command                        | Description                    |
+| ------------------------------ | ------------------------------ |
+| `propre scan [path]`           | Full analysis (no changes)     |
+| `propre fix [path]`            | Auto-fix safe issues           |
+| `propre res [path]`            | Project restructuring only     |
+| `propre sec [path]`            | Secret scanning only           |
+| `propre ship [path]`           | Production readiness checklist |
+| `propre report [path] -o file` | Export full report             |
+
+
+---
+
+## Common Workflows
+
+### Before committing AI-generated code
+
+```bash
+propre scan .
+```
+
+### Before opening a pull request
+
+```bash
+propre fix .
+propre ship .
+```
+
+### CI safety check
+
+```bash
+propre scan . --ci
+```
+
+### Security audit
+
+```bash
+propre sec . --deep-scan
+```
+
+---
+
+## Global Flags
+
+| Flag                  | Description                            |      |        |               |
+| --------------------- | -------------------------------------- | ---- | ------ | ------------- |
+| `--dry-run`           | Preview changes without applying       |      |        |               |
+| `--verbose` / `-v`    | Detailed output                        |      |        |               |
+| `--config propre.yml` | Custom rules                           |      |        |               |
+| `--fix`               | Apply safe fixes outside `fix` command |      |        |               |
+| `--ignore <pattern>`  | Exclude paths                          |      |        |               |
+| `--ci`                | Exit non-zero if blockers found        |      |        |               |
+| `--format terminal    | md                                     | json | sarif` | Output format |
+
+---
+
+## Configuration
+
+Create a `propre.yml` at your project root:
+
+```yaml
+stack: auto
+
+restructure:
+    enabled: true
+    confirm: true
+
+secrets:
+    deep_scan: false
+    severity_threshold: medium
+
+rules:
+    dead_code: warn
+    console_logs: error
+    missing_types: warn
+    hardcoded_config: error
+
+ignore:
+    - node_modules/
+    - .git/
+    - dist/
+```
+
+---
+
+## What Propre Detects
+
+- Dead code & unused files
+- Debug logs & leftover prints
+- Missing typing
+- Hardcoded configuration
+- Project structure issues
+- Secrets & credentials
+- Production blockers
+
+---
+
+## CI Integration
+
+Example GitHub Action step:
+
+```bash
+propre scan . --ci
+```
+
+The command exits with a non-zero code if blocking issues are found.
+
+---
+
+## Philosophy
+
+Modern coding workflows generate code faster than they validate it.
+
+Propre acts as the **final safety layer** between experimentation and deployment:
+
+- AI coding assistants create
+- Developers iterate
+- **Propre hardens**
+
+---
+
+## License
+
+MIT
+
+---

propre_cli-0.1.0/propre/__init__.py

@@ -0,0 +1,5 @@
+"""Propre package."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

propre_cli-0.1.0/propre/__main__.py

@@ -0,0 +1,4 @@
+from propre.cli import run
+
+if __name__ == "__main__":
+    run()

propre_cli-0.1.0/propre/cli.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import typer
+
+from propre.config import load_config
+from propre.context import RunContext, RuntimeOptions
+from propre.engine import PropreEngine
+from propre.models import OutputFormat
+from propre.reporters.renderers import emit_report
+
+app = typer.Typer(
+    add_completion=False,
+    help="Propre: post-vibe-coding architecture cleanup and hardening CLI.",
+)
+
+
+def _resolve_phases(command: str, restructure_enabled: bool) -> list[str]:
+    if command in {"scan", "report"}:
+        phases = ["scan"]
+        if restructure_enabled:
+            phases.append("restructure")
+        phases.extend(["secrets", "harden", "ship"])
+        return phases
+    if command == "fix":
+        phases = ["scan"]
+        if restructure_enabled:
+            phases.append("restructure")
+        phases.extend(["secrets", "harden", "ship"])
+        return phases
+    if command == "restructure":
+        return ["scan", "restructure"]
+    if command == "secrets":
+        return ["secrets"]
+    if command == "ship":
+        return ["ship"]
+    raise ValueError(f"Unknown command: {command}")
+
+
+def _build_context(
+    command: str,
+    path: Path,
+    global_options: dict[str, Any],
+    output_path: Path | None,
+    deep_scan: bool | None,
+) -> RunContext:
+    project_path = path.resolve()
+    config_path = Path(global_options["config"]).resolve() if global_options.get("config") else None
+    loaded = load_config(project_path, config_path)
+
+    auto_fix = bool(global_options["fix"] or command in {"fix", "restructure"})
+
+    runtime = RuntimeOptions(
+        command=command,
+        dry_run=bool(global_options["dry_run"]),
+        verbose=bool(global_options["verbose"]),
+        auto_fix=auto_fix,
+        ci=bool(global_options["ci"]),
+        output_format=OutputFormat(global_options["format"]),
+        output_path=output_path,
+        ignore=list(global_options["ignore"]),
+        deep_scan=deep_scan,
+    )
+
+    return RunContext(project_path=project_path, loaded_config=loaded, options=runtime)
+
+
+def _run(
+    ctx: typer.Context,
+    command: str,
+    path: Path,
+    output_path: Path | None = None,
+    deep_scan: bool | None = None,
+) -> None:
+    runtime_ctx = _build_context(command, path, ctx.obj, output_path, deep_scan)
+
+    if runtime_ctx.options.verbose:
+        config_source = runtime_ctx.loaded_config.source or "defaults"
+        runtime_ctx.console.print(f"[cyan]Config:[/cyan] {config_source}")
+
+    engine = PropreEngine(runtime_ctx)
+    phases = _resolve_phases(command, runtime_ctx.config.restructure.enabled)
+    report = engine.run(phases)
+
+    emit_report(
+        report,
+        output_format=runtime_ctx.options.output_format.value,
+        console=runtime_ctx.console,
+        output_path=runtime_ctx.options.output_path,
+    )
+
+    if runtime_ctx.options.ci:
+        failed_checks = any(not check.passed for phase in report.phases for check in phase.checks)
+        if report.has_blockers() or failed_checks:
+            raise typer.Exit(code=1)
+
+
+@app.callback()
+def common_options(
+    ctx: typer.Context,
+    dry_run: bool = typer.Option(False, "--dry-run", help="Preview changes without applying them."),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose output."),
+    config: Path | None = typer.Option(None, "--config", help="Path to propre.yml config file."),
+    fix: bool = typer.Option(False, "--fix", help="Auto-apply safe fixes."),
+    ignore: list[str] = typer.Option([], "--ignore", help="Ignore glob/prefix pattern."),
+    ci: bool = typer.Option(False, "--ci", help="Exit non-zero on failures/blockers."),
+    format: OutputFormat = typer.Option(OutputFormat.TERMINAL, "--format", help="Output format."),
+) -> None:
+    ctx.obj = {
+        "dry_run": dry_run,
+        "verbose": verbose,
+        "config": str(config) if config else None,
+        "fix": fix,
+        "ignore": ignore,
+        "ci": ci,
+        "format": format.value,
+    }
+
+
+@app.command()
+def scan(
+    ctx: typer.Context,
+    path: Path = typer.Argument(Path("."), exists=True, file_okay=False, dir_okay=True),
+    deep_scan: bool | None = typer.Option(
+        None,
+        "--deep-scan/--no-deep-scan",
+        help="Also scan git history for secrets.",
+    ),
+) -> None:
+    """Full analysis, no changes unless --fix is set."""
+    _run(ctx, "scan", path, deep_scan=deep_scan)
+
+
+@app.command()
+def fix(
+    ctx: typer.Context,
+    path: Path = typer.Argument(Path("."), exists=True, file_okay=False, dir_okay=True),
+    deep_scan: bool | None = typer.Option(
+        None,
+        "--deep-scan/--no-deep-scan",
+        help="Also scan git history for secrets.",
+    ),
+) -> None:
+    """Auto-fix safe issues where possible."""
+    _run(ctx, "fix", path, deep_scan=deep_scan)
+
+
+@app.command("res")
+def restructure(
+    ctx: typer.Context,
+    path: Path = typer.Argument(Path("."), exists=True, file_okay=False, dir_okay=True),
+) -> None:
+    """Folder restructuring only."""
+    _run(ctx, "restructure", path)
+
+
+@app.command("sec")
+def secrets(
+    ctx: typer.Context,
+    path: Path = typer.Argument(Path("."), exists=True, file_okay=False, dir_okay=True),
+    deep_scan: bool | None = typer.Option(
+        None,
+        "--deep-scan/--no-deep-scan",
+        help="Also scan git history for secrets.",
+    ),
+) -> None:
+    """Secret scanning only."""
+    _run(ctx, "secrets", path, deep_scan=deep_scan)
+
+
+@app.command()
+def ship(
+    ctx: typer.Context,
+    path: Path = typer.Argument(Path("."), exists=True, file_okay=False, dir_okay=True),
+) -> None:
+    """Production readiness checklist."""
+    _run(ctx, "ship", path)
+
+
+@app.command()
+def report(
+    ctx: typer.Context,
+    path: Path = typer.Argument(Path("."), exists=True, file_okay=False, dir_okay=True),
+    output: Path = typer.Option(Path("report.md"), "-o", "--output", help="Write report to this file."),
+    deep_scan: bool | None = typer.Option(
+        None,
+        "--deep-scan/--no-deep-scan",
+        help="Also scan git history for secrets.",
+    ),
+) -> None:
+    """Export a full report file."""
+    _run(ctx, "report", path, output_path=output, deep_scan=deep_scan)
+
+
+def run() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    run()