codex-workspace-bootstrap 0.3.0__py3-none-any.whl

codex_workspace_bootstrap/__init__.py

@@ -0,0 +1,3 @@
+"""codex-workspace-bootstrap package."""
+
+__version__ = "0.3.0"

codex_workspace_bootstrap/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codex_workspace_bootstrap/agents.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+PYTHON_MARKERS = ("pyproject.toml", "requirements.txt", "setup.py", "setup.cfg")
+NODE_MARKER = "package.json"
+
+
+def detect_project_signals(root: Path) -> list[str]:
+    signals: list[str] = []
+    if any((root / marker).exists() for marker in PYTHON_MARKERS):
+        signals.append("Python")
+    if (root / NODE_MARKER).exists():
+        signals.append("Node.js")
+    return signals
+
+
+def _node_script_names(root: Path) -> set[str]:
+    package_json = root / NODE_MARKER
+    if not package_json.exists():
+        return set()
+
+    try:
+        data = json.loads(package_json.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+        return set()
+
+    scripts = data.get("scripts")
+    if not isinstance(scripts, dict):
+        return set()
+
+    return {name for name, value in scripts.items() if isinstance(name, str) and isinstance(value, str)}
+
+
+def validation_commands(root: Path) -> list[str]:
+    signals = detect_project_signals(root)
+    commands: list[str] = []
+
+    if "Python" in signals:
+        if (root / "tests").is_dir():
+            commands.append("python -m pytest")
+        else:
+            commands.append("python -m compileall .")
+
+    if "Node.js" in signals:
+        scripts = _node_script_names(root)
+        if "test" in scripts:
+            commands.append("npm test")
+        if "lint" in scripts:
+            commands.append("npm run lint")
+        if not {"test", "lint"} & scripts:
+            commands.append("npm install --ignore-scripts --package-lock-only --dry-run")
+
+    commands.extend(
+        [
+            "codex-workspace-bootstrap audit . --strict",
+            "git diff --check",
+            "git status --short",
+        ]
+    )
+    return commands
+
+
+def generate_agents(root: Path) -> str:
+    signals = detect_project_signals(root)
+    signal_text = ", ".join(signals) if signals else "No common Python or Node.js manifest detected"
+    commands = validation_commands(root)
+    command_lines = "\n".join(f"- `{command}`" for command in commands)
+
+    return f"""# AGENTS.md
+
+## Purpose
+
+This repository is maintained with assistance from Codex.
+
+## Detected project signals
+
+{signal_text}
+
+These signals are derived only from files present in the repository. Review this file before relying on the generated commands.
+
+## Working rules
+
+- Read README files and relevant project manifests before editing.
+- Keep changes scoped to the requested issue or task.
+- Do not add secrets, credentials, tokens, private data, or generated environment files.
+- Prefer deterministic, scriptable commands over manual steps.
+- Preserve existing platform support unless the task explicitly changes it.
+- Add or update tests for behavior changes when the repository has a test suite.
+- Explain user-visible behavior changes in the pull request or commit summary.
+- Inspect the final diff before proposing completion.
+
+## Suggested validation
+
+Run the commands that apply to the change:
+
+{command_lines}
+
+If a generated command does not match the repository's documented workflow, follow the repository documentation and update this file rather than forcing the command to run.
+
+## Safety
+
+- Do not print the contents of files suspected to contain secrets.
+- Do not overwrite user files without explicit approval.
+- Treat successful automated checks as evidence, not as a security guarantee.
+"""

codex_workspace_bootstrap/audit.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from pathlib import Path
+import shutil
+import subprocess
+from typing import Iterable
+
+
+@dataclass(frozen=True)
+class Check:
+    name: str
+    status: str
+    message: str
+    blocking: bool = False
+
+    def to_dict(self) -> dict[str, object]:
+        return asdict(self)
+
+
+COMMON_TOOLS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("git", ("git", "--version")),
+    ("python", ("python", "--version")),
+    ("node", ("node", "--version")),
+    ("npm", ("npm", "--version")),
+    ("powershell", ("powershell", "-NoProfile", "-Command", "$PSVersionTable.PSVersion.ToString()")),
+    ("wsl", ("wsl", "--status")),
+    ("codex", ("codex", "--version")),
+)
+
+MANIFESTS = (
+    "pyproject.toml",
+    "requirements.txt",
+    "package.json",
+    "go.mod",
+    "Cargo.toml",
+    "pom.xml",
+    "build.gradle",
+)
+
+RISK_FILENAMES = {
+    ".env",
+    ".env.local",
+    "credentials.json",
+    "service-account.json",
+    "id_rsa",
+    "id_ed25519",
+}
+
+RISK_SUFFIXES = (".pem", ".p12", ".pfx", ".key")
+
+
+def _tool_check(label: str, command: tuple[str, ...]) -> Check:
+    executable = shutil.which(command[0])
+    if not executable:
+        return Check(label, "warn", f"{command[0]} command not found")
+
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+        output = (result.stdout or result.stderr).strip().splitlines()
+        detail = output[0] if output else "available"
+        if result.returncode == 0:
+            return Check(label, "pass", detail)
+        return Check(label, "warn", f"available but returned exit code {result.returncode}")
+    except (OSError, subprocess.SubprocessError) as exc:
+        return Check(label, "warn", f"could not execute: {exc}")
+
+
+def _iter_project_files(root: Path) -> Iterable[Path]:
+    excluded = {".git", ".venv", "venv", "node_modules", "__pycache__"}
+    for path in root.rglob("*"):
+        if any(part in excluded for part in path.parts):
+            continue
+        if path.is_file():
+            yield path
+
+
+def _git_matches(root: Path, args: tuple[str, ...]) -> bool:
+    if shutil.which("git") is None:
+        return False
+    try:
+        result = subprocess.run(
+            ("git", "-C", str(root), *args),
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+        return result.returncode == 0
+    except (OSError, subprocess.SubprocessError):
+        return False
+
+
+def _classify_risky_paths(root: Path, risky: list[str]) -> tuple[list[str], list[str], list[str]]:
+    tracked: list[str] = []
+    ignored: list[str] = []
+    untracked: list[str] = []
+
+    for relative in risky:
+        if _git_matches(root, ("ls-files", "--error-unmatch", "--", relative)):
+            tracked.append(relative)
+        elif _git_matches(root, ("check-ignore", "--quiet", "--", relative)):
+            ignored.append(relative)
+        else:
+            untracked.append(relative)
+
+    return tracked, ignored, untracked
+
+
+def _preview(paths: list[str], limit: int = 8) -> str:
+    visible = ", ".join(sorted(paths)[:limit])
+    suffix = "" if len(paths) <= limit else f" (+{len(paths) - limit} more)"
+    return f"{visible}{suffix}"
+
+
+def audit_repository(root: Path) -> list[Check]:
+    root = root.resolve()
+    checks: list[Check] = []
+
+    git_dir = root / ".git"
+    checks.append(
+        Check(
+            "git-repository",
+            "pass" if git_dir.exists() else "warn",
+            "Git repository detected" if git_dir.exists() else ".git directory not found",
+        )
+    )
+
+    readme = next((p for p in root.iterdir() if p.is_file() and p.name.lower().startswith("readme")), None)
+    checks.append(
+        Check(
+            "readme",
+            "pass" if readme else "warn",
+            f"README detected: {readme.name}" if readme else "README not found",
+        )
+    )
+
+    license_file = next((p for p in root.iterdir() if p.is_file() and p.name.lower().startswith("license")), None)
+    checks.append(
+        Check(
+            "license",
+            "pass" if license_file else "warn",
+            f"License detected: {license_file.name}" if license_file else "License file not found",
+        )
+    )
+
+    checks.append(
+        Check(
+            "gitignore",
+            "pass" if (root / ".gitignore").exists() else "warn",
+            ".gitignore detected" if (root / ".gitignore").exists() else ".gitignore not found",
+        )
+    )
+
+    checks.append(
+        Check(
+            "agents",
+            "pass" if (root / "AGENTS.md").exists() else "warn",
+            "AGENTS.md detected" if (root / "AGENTS.md").exists() else "AGENTS.md not found; run init-agents",
+        )
+    )
+
+    manifests = [name for name in MANIFESTS if (root / name).exists()]
+    checks.append(
+        Check(
+            "project-manifest",
+            "pass" if manifests else "warn",
+            f"Detected: {', '.join(manifests)}" if manifests else "No common project manifest detected",
+        )
+    )
+
+    for label, command in COMMON_TOOLS:
+        checks.append(_tool_check(label, command))
+
+    risky: list[str] = []
+    for path in _iter_project_files(root):
+        name = path.name.lower()
+        if name in RISK_FILENAMES or name.endswith(RISK_SUFFIXES):
+            risky.append(path.relative_to(root).as_posix())
+
+    if risky:
+        tracked, ignored, untracked = _classify_risky_paths(root, risky)
+        parts: list[str] = []
+        if tracked:
+            parts.append(f"tracked: {_preview(tracked)}")
+        if ignored:
+            parts.append(f"ignored: {_preview(ignored)}")
+        if untracked:
+            parts.append(f"untracked/unknown: {_preview(untracked)}")
+
+        checks.append(
+            Check(
+                "secret-risk-files",
+                "warn",
+                "Potential secret-bearing filenames detected (" + "; ".join(parts) + "). "
+                "The audit does not read file contents.",
+                blocking=bool(tracked),
+            )
+        )
+    else:
+        checks.append(Check("secret-risk-files", "pass", "No common secret-bearing filenames detected"))
+
+    return checks
+
+
+def summary(checks: list[Check]) -> dict[str, int]:
+    return {
+        "passed": sum(c.status == "pass" for c in checks),
+        "warnings": sum(c.status == "warn" for c in checks),
+        "blocking": sum(c.blocking for c in checks),
+    }

codex_workspace_bootstrap/cli.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+from . import __version__
+from .agents import generate_agents
+from .audit import audit_repository, summary
+from .sarif import checks_to_sarif
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="codex-workspace-bootstrap",
+        description="Audit and bootstrap repositories for reliable Codex workflows.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    audit = sub.add_parser("audit", help="Audit a repository and local toolchain")
+    audit.add_argument("path", nargs="?", default=".")
+    audit.add_argument("--json", dest="json_path", help="Write the complete report to a JSON file")
+    audit.add_argument("--sarif", dest="sarif_path", help="Write warnings and blocking findings as SARIF 2.1.0")
+    audit.add_argument(
+        "--strict",
+        action="store_true",
+        help="Return a non-zero exit code if blocking checks are present",
+    )
+
+    init_agents = sub.add_parser("init-agents", help="Create a project-aware starter AGENTS.md")
+    init_agents.add_argument("path", nargs="?", default=".")
+    init_agents.add_argument("--force", action="store_true", help="Overwrite an existing AGENTS.md")
+
+    return parser
+
+
+def _write_json(path: str, payload: object, label: str) -> None:
+    output = Path(path).expanduser().resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    print(f"{label} written to: {output}")
+
+
+def _run_audit(
+    path: str,
+    json_path: str | None,
+    sarif_path: str | None,
+    strict: bool,
+) -> int:
+    root = Path(path).expanduser().resolve()
+    if not root.exists() or not root.is_dir():
+        print(f"error: repository path does not exist or is not a directory: {root}", file=sys.stderr)
+        return 2
+
+    checks = audit_repository(root)
+    totals = summary(checks)
+
+    print(f"Repository: {root}")
+    for check in checks:
+        tag = "PASS" if check.status == "pass" else "WARN"
+        print(f"[{tag}] {check.name}: {check.message}")
+
+    print(
+        f"Summary: {totals['passed']} passed, "
+        f"{totals['warnings']} warnings, {totals['blocking']} blocking"
+    )
+
+    if json_path:
+        _write_json(
+            json_path,
+            {
+                "repository": str(root),
+                "checks": [c.to_dict() for c in checks],
+                "summary": totals,
+            },
+            "JSON report",
+        )
+
+    if sarif_path:
+        _write_json(sarif_path, checks_to_sarif(checks), "SARIF report")
+
+    if strict and totals["blocking"]:
+        return 1
+    return 0
+
+
+def _run_init_agents(path: str, force: bool) -> int:
+    root = Path(path).expanduser().resolve()
+    if not root.exists() or not root.is_dir():
+        print(f"error: path does not exist or is not a directory: {root}", file=sys.stderr)
+        return 2
+
+    target = root / "AGENTS.md"
+    if target.exists() and not force:
+        print(f"error: {target} already exists; use --force to overwrite", file=sys.stderr)
+        return 1
+
+    target.write_text(generate_agents(root), encoding="utf-8")
+    print(f"Created {target}")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    if args.command == "audit":
+        return _run_audit(args.path, args.json_path, args.sarif_path, args.strict)
+    if args.command == "init-agents":
+        return _run_init_agents(args.path, args.force)
+    return 2

codex_workspace_bootstrap/sarif.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+from . import __version__
+from .audit import Check
+
+
+RULE_HELP: dict[str, str] = {
+    "git-repository": "Run the audit from the intended Git repository root when repository-aware checks are needed.",
+    "readme": "Add or identify project documentation that explains how contributors should work with the repository.",
+    "license": "Add an explicit open-source license when the project is intended for public reuse.",
+    "gitignore": "Use ignore rules to keep generated, local, and secret-bearing files out of version control.",
+    "agents": "Add or generate AGENTS.md so agent-assisted work has repository-specific instructions.",
+    "project-manifest": "Add or identify the project manifest that describes the repository toolchain.",
+    "git": "Install Git or make it available on PATH when Git-aware checks are required.",
+    "python": "Install Python or make it available on PATH when the repository requires Python.",
+    "node": "Install Node.js or make it available on PATH when the repository requires Node.js.",
+    "npm": "Install npm or make it available on PATH when the repository requires npm.",
+    "powershell": "Install or expose PowerShell when Windows PowerShell workflows are required.",
+    "wsl": "Install or configure WSL only when the repository workflow requires it.",
+    "codex": "Install or expose the Codex CLI when local Codex command checks are required.",
+    "secret-risk-files": "Review risky filenames before publishing or merging. The audit does not read file contents.",
+}
+
+
+def _rule(check: Check) -> dict[str, object]:
+    help_text = RULE_HELP.get(
+        check.name,
+        "Review this repository-readiness finding and update project documentation or tooling as appropriate.",
+    )
+    return {
+        "id": check.name,
+        "name": check.name,
+        "shortDescription": {"text": f"codex-workspace-bootstrap: {check.name}"},
+        "fullDescription": {"text": help_text},
+        "help": {"text": help_text},
+        "properties": {
+            "precision": "high" if check.blocking else "medium",
+            "tags": ["codex", "repository-readiness"],
+        },
+    }
+
+
+def checks_to_sarif(checks: Iterable[Check]) -> dict[str, object]:
+    findings = [check for check in checks if check.status != "pass"]
+    rule_ids = sorted({check.name for check in findings})
+    rule_by_id = {
+        check.name: _rule(check)
+        for check in findings
+    }
+
+    results: list[dict[str, object]] = []
+    for check in findings:
+        results.append(
+            {
+                "ruleId": check.name,
+                "level": "error" if check.blocking else "warning",
+                "message": {"text": check.message},
+                "properties": {
+                    "blocking": check.blocking,
+                    "source": "codex-workspace-bootstrap",
+                },
+            }
+        )
+
+    return {
+        "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
+        "version": "2.1.0",
+        "runs": [
+            {
+                "tool": {
+                    "driver": {
+                        "name": "codex-workspace-bootstrap",
+                        "informationUri": "https://github.com/kohli217/codex-workspace-bootstrap",
+                        "version": __version__,
+                        "rules": [rule_by_id[rule_id] for rule_id in rule_ids],
+                    }
+                },
+                "results": results,
+            }
+        ],
+    }

codex_workspace_bootstrap-0.3.0.dist-info/METADATA

@@ -0,0 +1,235 @@
+Metadata-Version: 2.4
+Name: codex-workspace-bootstrap
+Version: 0.3.0
+Summary: Audit and bootstrap Windows repositories for effective Codex workflows.
+Author: kohli217
+License: MIT
+Project-URL: Homepage, https://github.com/kohli217/codex-workspace-bootstrap
+Project-URL: Repository, https://github.com/kohli217/codex-workspace-bootstrap
+Project-URL: Issues, https://github.com/kohli217/codex-workspace-bootstrap/issues
+Project-URL: Changelog, https://github.com/kohli217/codex-workspace-bootstrap/blob/main/CHANGELOG.md
+Keywords: codex,openai,windows,developer-tools,cli,oss,agents-md
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# codex-workspace-bootstrap
+
+[![CI](https://github.com/kohli217/codex-workspace-bootstrap/actions/workflows/ci.yml/badge.svg)](https://github.com/kohli217/codex-workspace-bootstrap/actions/workflows/ci.yml)
+[![CodeQL](https://github.com/kohli217/codex-workspace-bootstrap/actions/workflows/codeql.yml/badge.svg)](https://github.com/kohli217/codex-workspace-bootstrap/actions/workflows/codeql.yml)
+[![Release](https://img.shields.io/github/v/release/kohli217/codex-workspace-bootstrap)](https://github.com/kohli217/codex-workspace-bootstrap/releases/latest)
+[![License](https://img.shields.io/github/license/kohli217/codex-workspace-bootstrap)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue)](pyproject.toml)
+
+Make Windows repositories **Codex-ready** with automated environment checks, project instructions, safety audits, and maintainer workflows.
+
+[日本語ガイド](docs/README.ja.md) · [Examples](docs/EXAMPLES.md) · [Roadmap](docs/ROADMAP.md) · [Releases](https://github.com/kohli217/codex-workspace-bootstrap/releases)
+
+> Community-maintained project. It is not an official OpenAI product and is not affiliated with OpenAI.
+
+## What problem does it solve?
+
+Codex works better when a repository clearly states its toolchain, validation commands, constraints, and maintenance workflow. On Windows, those details are often scattered across README files, shell history, and machine-specific assumptions.
+
+`codex-workspace-bootstrap` gives maintainers one repeatable entry point to:
+
+- audit Git, Python, Node.js, npm, PowerShell, WSL, and Codex availability;
+- inspect repository basics such as README, license, ignore rules, manifests, and `AGENTS.md`;
+- warn about common secret-bearing filenames without reading their contents;
+- distinguish tracked risky files from ignored or untracked files when Git is available;
+- generate a project-aware `AGENTS.md` for Python, Node.js, mixed, or unknown projects;
+- write machine-readable JSON and SARIF 2.1.0 reports;
+- fail CI on blocking findings with `--strict`;
+- validate releases through automated tests, self-audit, and build checks.
+
+## Why Windows-first?
+
+The project targets a real repository-readiness problem around Windows and Windows+WSL development. It does not claim to fix upstream Codex product bugs. See [docs/MOTIVATION.md](docs/MOTIVATION.md) for the scope and public upstream references.
+
+## 30-second start
+
+Install the pinned v0.3.0 wheel:
+
+```powershell
+py -m pip install "https://github.com/kohli217/codex-workspace-bootstrap/releases/download/v0.3.0/codex_workspace_bootstrap-0.3.0-py3-none-any.whl"
+```
+
+Audit the current repository:
+
+```powershell
+codex-workspace-bootstrap audit .
+```
+
+Generate project instructions:
+
+```powershell
+codex-workspace-bootstrap init-agents .
+```
+
+Check the installed version:
+
+```powershell
+codex-workspace-bootstrap --version
+```
+
+For more examples, see [docs/EXAMPLES.md](docs/EXAMPLES.md).
+
+## Why a pinned release instead of `irm ... | iex`?
+
+The recommended quick start installs a specific published wheel so users can see exactly which release they are installing. A PowerShell helper script remains available in [scripts/install.ps1](scripts/install.ps1), but piping remote scripts directly into PowerShell is not the recommended path.
+
+## GitHub Action
+
+Use the tool directly in an OSS repository workflow:
+
+```yaml
+- uses: actions/checkout@v7
+- uses: actions/setup-python@v7
+  with:
+    python-version: "3.13"
+- uses: kohli217/codex-workspace-bootstrap@v0.3.0
+  with:
+    path: .
+    strict: "true"
+```
+
+See [docs/GITHUB_ACTION.md](docs/GITHUB_ACTION.md) for the full workflow and input reference.
+
+## Commands
+
+### Audit a repository
+
+```powershell
+codex-workspace-bootstrap audit .
+```
+
+Write JSON output:
+
+```powershell
+codex-workspace-bootstrap audit . --json audit-report.json
+```
+
+Use strict mode in CI:
+
+```powershell
+codex-workspace-bootstrap audit . --strict
+```
+
+### SARIF / Code Scanning
+
+```powershell
+codex-workspace-bootstrap audit . --sarif codex-workspace-bootstrap.sarif
+```
+
+Blocking findings are emitted as SARIF errors and other warnings as SARIF warnings. See [docs/SARIF.md](docs/SARIF.md) for GitHub Code Scanning integration.
+
+### Generate `AGENTS.md`
+
+```powershell
+codex-workspace-bootstrap init-agents .
+```
+
+The generator inspects common project manifests and layout signals, then writes conservative validation guidance. Existing `AGENTS.md` files are never overwritten unless `--force` is explicit.
+
+## Safety model
+
+- The core audit path performs local inspection only.
+- The tool does **not** read or print the contents of suspected secret files.
+- The tool does **not** send repository contents to a remote service.
+- A passing audit is evidence about the checks performed, **not** a security guarantee.
+- File modifications are opt-in; existing `AGENTS.md` files are protected by default.
+
+See [SECURITY.md](SECURITY.md) for reporting guidance.
+
+## Maintainer workflow
+
+This project uses an issue → branch → pull request → CI → merge → release workflow.
+
+Current automated checks include:
+
+- Windows and Ubuntu test matrices on Python 3.10 and 3.13;
+- built-wheel smoke testing;
+- strict self-audit before releases;
+- CodeQL static analysis;
+- weekly dependency update checks for Python and GitHub Actions;
+- validated one-click GitHub releases with attached wheel and source distribution.
+
+Release history began with [v0.1.0](https://github.com/kohli217/codex-workspace-bootstrap/releases/tag/v0.1.0).
+
+## Codex-oriented workflow
+
+A practical repository workflow is:
+
+1. run `audit`;
+2. review warnings and blocking findings;
+3. generate or review `AGENTS.md`;
+4. give Codex a scoped issue or task;
+5. run the repository tests and the audit again;
+6. inspect the diff before merge;
+7. release only after CI passes.
+
+See [AGENTS.md](AGENTS.md) for this repository's own agent instructions and [skills/codex-workspace-bootstrap/SKILL.md](skills/codex-workspace-bootstrap/SKILL.md) for the reusable skill.
+
+## Project scope
+
+### In scope
+
+- Windows-first repository readiness checks;
+- Codex-oriented project instructions;
+- maintainer automation that is deterministic and reviewable;
+- CI-friendly reporting and safe defaults.
+
+### Not in scope
+
+- claiming that a repository is secure because an audit passed;
+- silently changing user configuration;
+- uploading repository contents by default;
+- replacing project-specific documentation or human review.
+
+## Development
+
+```powershell
+git clone https://github.com/kohli217/codex-workspace-bootstrap.git
+cd codex-workspace-bootstrap
+py -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install -e . pytest
+pytest -q
+```
+
+Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md), [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md), and [SUPPORT.md](SUPPORT.md).
+
+## Maintainer and adoption
+
+Primary maintainer identity and responsibilities are documented in [MAINTAINERS.md](MAINTAINERS.md).
+
+If you use the project, please share a real usage report through the GitHub issue template. The project deliberately avoids fabricated testimonials or adoption claims. See [docs/ADOPTION.md](docs/ADOPTION.md).
+
+## Roadmap
+
+See [docs/ROADMAP.md](docs/ROADMAP.md).
+
+## Releasing
+
+Maintainers can create a tested GitHub release from the Actions UI. See [docs/RELEASING.md](docs/RELEASING.md).
+
+## Citation
+
+Machine-readable citation metadata is available in [CITATION.cff](CITATION.cff).
+
+## License
+
+MIT. See [LICENSE](LICENSE).

codex_workspace_bootstrap-0.3.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+codex_workspace_bootstrap/__init__.py,sha256=0OEVFJTfc3mhl8r58ymaT2GxKMDOfbq1ChGhkkliqgY,64
+codex_workspace_bootstrap/__main__.py,sha256=MHKZ_ae3fSLGTLUUMOx15fWdeOnJSHhq-zslRP5F5Lc,79
+codex_workspace_bootstrap/agents.py,sha256=pxMqikz31WwMVWqFihLjM5sV-ZVgq1AhExPGBHnfikc,3445
+codex_workspace_bootstrap/audit.py,sha256=QKWyVNZlFz5OnmPQX0uU6sMz2l_615qnTLjkNuPvPno,6522
+codex_workspace_bootstrap/cli.py,sha256=YK9mrVXozsGSx6oKpkvIw-Vd9hUE3JU5fLp7y4T9tYo,3661
+codex_workspace_bootstrap/sarif.py,sha256=4DolD85AP2jltI6aR8V7bIB83aZ9WUi8d8qCBleQC3U,3522
+codex_workspace_bootstrap-0.3.0.dist-info/licenses/LICENSE,sha256=7egY_zVehKY142s1eL6Cxft2bUxYat41p-mjFNSCfKs,1065
+codex_workspace_bootstrap-0.3.0.dist-info/METADATA,sha256=nBX03JlQMjALNM0x2wGlJ_9jshJcZyWnKiEpg0t4nKM,8752
+codex_workspace_bootstrap-0.3.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+codex_workspace_bootstrap-0.3.0.dist-info/entry_points.txt,sha256=lNdzIlqHu37wfR8sRuDlU46nBs7JDEvI2fY4MLN_JJg,81
+codex_workspace_bootstrap-0.3.0.dist-info/top_level.txt,sha256=ujZkoqd5P_E7r-xvkaBHKcvb02xsv7yvTlHNCAIUL0M,26
+codex_workspace_bootstrap-0.3.0.dist-info/RECORD,,

codex_workspace_bootstrap-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codex_workspace_bootstrap-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codex-workspace-bootstrap = codex_workspace_bootstrap.cli:main

codex_workspace_bootstrap-0.3.0.dist-info/licenses/LICENSE

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

codex_workspace_bootstrap-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+codex_workspace_bootstrap