gator-command 1.0.0__tar.gz

gator_command-1.0.0/LICENSE

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

gator_command-1.0.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: gator-command
+Version: 1.0.0
+Summary: Git-native governance for AI-assisted engineering
+Author-email: Cumberland Laboratories <support@cumberlandlaboratories.com>
+License: MIT
+Project-URL: Homepage, https://github.com/cumberland-laboratories/gator
+Project-URL: Repository, https://github.com/cumberland-laboratories/gator
+Keywords: governance,ai,git,charters,audit,compliance
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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 :: Version Control :: Git
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Gator Command
+
+The command post for [Gator](https://github.com/cumberland-laboratories/gator) — AI-assisted engineering governance.
+
+## How to Use This Repo
+
+**Open it in an AI coding assistant.** Claude Code, Codex, Gemini CLI, Cursor — whichever you use. The agent reads the constitution and acts as your concierge: it knows the architecture, the configuration options, the procedures, and the fleet state. Ask it what you need.
+
+Gator is designed to be operated *with* an AI agent, not studied as documentation. The governance layer is markdown that agents read natively. The concierge layer routes your questions to the right procedures and reference material. The agent is the interface.
+
+```
+You: "gator init"
+You: "Gatorize my project at ~/code/my-app"
+You: "Set up an enforcer using GPT as the reviewer"
+You: "Check if the charters still match the code"
+You: "What's the status of the fleet?"
+```
+
+## What Gator Does
+
+Gator governs AI-assisted coding. It keeps human comprehension synchronized with AI-generated code through constitutions, module charters, deterministic commit gates, and cross-model enforcement.
+
+### Use Cases
+
+**Solo developer with one repo** — You want the AI agent to maintain a map of your codebase (charters), enforce that the map stays current (commit gate), and preserve session context across conversations (knowledge layer). Install Gator, bootstrap charters, and the loop runs from there.
+
+**Solo developer with multiple repos** — Same as above, plus: this command post becomes your cross-repo control plane. One org policy propagated to every repo. Fleet status, drift detection, and audit dashboards from one place.
+
+**Team with shared repos** — Gator's knowledge layer travels with the repo via git. When a teammate (human or AI) opens the repo, they get the full architectural context — mission, charters, threads, decisions. The enforcer provides independent review from a different model than the one writing code.
+
+**Compliance and audit** — Every commit carries `Gator-*` trailers (change type, significance, charter status, agent identity). Session summaries provide durable evidence of what was decided and who was supervising. Fleet-wide audit reports aggregate governance health across repos.
+
+### Configurations
+
+Gator is model-neutral and modular. The PI chooses the configuration that fits their stack:
+
+| Decision | Options |
+|----------|---------|
+| **Primary agent** | Claude Code, Codex CLI, Gemini CLI, Cursor, any markdown-aware AI tool |
+| **Enforcer model** | Anthropic Sonnet, OpenAI GPT, Google Gemini, local via Ollama, or none |
+| **Review cadence** | Light (lint only), Standard (lint + model review on significant changes), Rigorous (pre-code + post-code review) |
+| **Fleet scope** | Single repo (no command post needed), multi-repo (this command post), remote repos (bare cache scanning) |
+| **Session archaeology** | Off, local spool, committed summaries (git-tracked audit trail) |
+
+The concierge agent walks you through these choices. You don't need to read configuration docs — tell the agent what you want and it configures the system.
+
+## Quick Start
+
+```bash
+# Gatorize an existing project repo
+bash gator-command/scripts/gatorize.sh /path/to/your/project
+
+# Then open that project in your AI assistant — the concierge bootstrap begins
+```
+
+For fleet operations (from within this command post):
+```bash
+# Fleet status
+python gator-command/scripts/gator-fleet-report.py
+
+# Policy drift across all governed repos
+python gator-command/scripts/gator-drift.py
+
+# Audit dashboard
+python gator-command/scripts/gator-audit.py
+```
+
+## Architecture at a Glance
+
+```
+This repo (command post):
+  constitution.md          Governance rules for this command post
+  gator-command/           Knowledge graph + machinery + fleet tooling
+    scripts/               CLI tooling (gatorize, fleet-report, drift, audit)
+    templates/             Starter kit deployed to project repos
+    procedures/            Standards and workflows
+    reference-notes/       Concierge knowledge (the agent reads these)
+
+Each governed repo:
+  .gator/
+    constitution.md        Per-repo governance rules
+    charters/              Module maps (the intelligent codebase layer)
+    scripts/               Hooks + enforcer
+    field-guides/          Language pattern references (optional)
+    command-post.md        Thin link back to this command post
+```
+
+## Multi-Model Architecture
+
+The constitutions are the interface contract. Any model that reads markdown and follows instructions can operate the system.
+
+- **Primary agent**: Reads charters, writes code, updates the knowledge layer
+- **Enforcer**: Different model, read-only, audits the agent's work against charters
+- **The architecture outlives any individual model** — switch tools mid-project without losing context
+
+## License
+
+MIT — [Cumberland Laboratories](https://github.com/cumberland-laboratories)

gator_command-1.0.0/README.md

@@ -0,0 +1,98 @@
+# Gator Command
+
+The command post for [Gator](https://github.com/cumberland-laboratories/gator) — AI-assisted engineering governance.
+
+## How to Use This Repo
+
+**Open it in an AI coding assistant.** Claude Code, Codex, Gemini CLI, Cursor — whichever you use. The agent reads the constitution and acts as your concierge: it knows the architecture, the configuration options, the procedures, and the fleet state. Ask it what you need.
+
+Gator is designed to be operated *with* an AI agent, not studied as documentation. The governance layer is markdown that agents read natively. The concierge layer routes your questions to the right procedures and reference material. The agent is the interface.
+
+```
+You: "gator init"
+You: "Gatorize my project at ~/code/my-app"
+You: "Set up an enforcer using GPT as the reviewer"
+You: "Check if the charters still match the code"
+You: "What's the status of the fleet?"
+```
+
+## What Gator Does
+
+Gator governs AI-assisted coding. It keeps human comprehension synchronized with AI-generated code through constitutions, module charters, deterministic commit gates, and cross-model enforcement.
+
+### Use Cases
+
+**Solo developer with one repo** — You want the AI agent to maintain a map of your codebase (charters), enforce that the map stays current (commit gate), and preserve session context across conversations (knowledge layer). Install Gator, bootstrap charters, and the loop runs from there.
+
+**Solo developer with multiple repos** — Same as above, plus: this command post becomes your cross-repo control plane. One org policy propagated to every repo. Fleet status, drift detection, and audit dashboards from one place.
+
+**Team with shared repos** — Gator's knowledge layer travels with the repo via git. When a teammate (human or AI) opens the repo, they get the full architectural context — mission, charters, threads, decisions. The enforcer provides independent review from a different model than the one writing code.
+
+**Compliance and audit** — Every commit carries `Gator-*` trailers (change type, significance, charter status, agent identity). Session summaries provide durable evidence of what was decided and who was supervising. Fleet-wide audit reports aggregate governance health across repos.
+
+### Configurations
+
+Gator is model-neutral and modular. The PI chooses the configuration that fits their stack:
+
+| Decision | Options |
+|----------|---------|
+| **Primary agent** | Claude Code, Codex CLI, Gemini CLI, Cursor, any markdown-aware AI tool |
+| **Enforcer model** | Anthropic Sonnet, OpenAI GPT, Google Gemini, local via Ollama, or none |
+| **Review cadence** | Light (lint only), Standard (lint + model review on significant changes), Rigorous (pre-code + post-code review) |
+| **Fleet scope** | Single repo (no command post needed), multi-repo (this command post), remote repos (bare cache scanning) |
+| **Session archaeology** | Off, local spool, committed summaries (git-tracked audit trail) |
+
+The concierge agent walks you through these choices. You don't need to read configuration docs — tell the agent what you want and it configures the system.
+
+## Quick Start
+
+```bash
+# Gatorize an existing project repo
+bash gator-command/scripts/gatorize.sh /path/to/your/project
+
+# Then open that project in your AI assistant — the concierge bootstrap begins
+```
+
+For fleet operations (from within this command post):
+```bash
+# Fleet status
+python gator-command/scripts/gator-fleet-report.py
+
+# Policy drift across all governed repos
+python gator-command/scripts/gator-drift.py
+
+# Audit dashboard
+python gator-command/scripts/gator-audit.py
+```
+
+## Architecture at a Glance
+
+```
+This repo (command post):
+  constitution.md          Governance rules for this command post
+  gator-command/           Knowledge graph + machinery + fleet tooling
+    scripts/               CLI tooling (gatorize, fleet-report, drift, audit)
+    templates/             Starter kit deployed to project repos
+    procedures/            Standards and workflows
+    reference-notes/       Concierge knowledge (the agent reads these)
+
+Each governed repo:
+  .gator/
+    constitution.md        Per-repo governance rules
+    charters/              Module maps (the intelligent codebase layer)
+    scripts/               Hooks + enforcer
+    field-guides/          Language pattern references (optional)
+    command-post.md        Thin link back to this command post
+```
+
+## Multi-Model Architecture
+
+The constitutions are the interface contract. Any model that reads markdown and follows instructions can operate the system.
+
+- **Primary agent**: Reads charters, writes code, updates the knowledge layer
+- **Enforcer**: Different model, read-only, audits the agent's work against charters
+- **The architecture outlives any individual model** — switch tools mid-project without losing context
+
+## License
+
+MIT — [Cumberland Laboratories](https://github.com/cumberland-laboratories)

gator_command-1.0.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gator-command"
+version = "1.0.0"
+description = "Git-native governance for AI-assisted engineering"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    {name = "Cumberland Laboratories", email = "support@cumberlandlaboratories.com"},
+]
+urls = {Homepage = "https://github.com/cumberland-laboratories/gator", Repository = "https://github.com/cumberland-laboratories/gator"}
+keywords = ["governance", "ai", "git", "charters", "audit", "compliance"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Version Control :: Git",
+]
+
+[project.scripts]
+gator = "gator_command.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+gator_command = [
+    "scripts/*.py",
+    "scripts/*.sh",
+    "scripts/*.md",
+    "scripts/dashboard/**/*",
+    "templates/**/*",
+    "templates/**/.*",
+]

gator_command-1.0.0/setup.cfg

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

gator_command-1.0.0/src/gator_command/__init__.py

@@ -0,0 +1,2 @@
+"""Gator Command — Git-native governance for AI-assisted engineering."""
+__version__ = "1.0.0"

gator_command-1.0.0/src/gator_command/cli.py

@@ -0,0 +1,137 @@
+"""
+gator — unified CLI for Gator Command.
+
+Dispatches to existing Gator scripts. This is the thin wrapper that makes
+`pipx install gator-command` → `gator <command>` work.
+
+For source-checkout and public-clone modes, scripts are resolved from the
+filesystem relative to gator_runtime.py. For installed-package mode,
+scripts are resolved from the package installation.
+"""
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+
+# ---------------------------------------------------------------------------
+# Script resolution
+# ---------------------------------------------------------------------------
+
+def _find_scripts_dir():
+    """Find the Gator scripts directory.
+
+    Resolution order:
+    1. Package-bundled scripts (works for pip install and pipx install)
+    2. Source checkout: gator-command/scripts/ relative to repo root
+    3. Public clone: gator-engine/scripts/ relative to repo root
+    """
+    cli_dir = Path(__file__).resolve().parent
+
+    # Installed package: scripts bundled as package data
+    candidate = cli_dir / "scripts"
+    if candidate.is_dir() and (candidate / "gator_core.py").exists():
+        return candidate
+
+    # Source checkout: cli.py is at src/gator_command/cli.py → repo root is ../../
+    repo_root = cli_dir.parent.parent
+    candidate = repo_root / "gator-command" / "scripts"
+    if candidate.is_dir() and (candidate / "gator_core.py").exists():
+        return candidate
+
+    # Public clone: gator-engine/scripts/
+    candidate = repo_root / "gator-engine" / "scripts"
+    if candidate.is_dir() and (candidate / "gator_core.py").exists():
+        return candidate
+
+    return None
+
+
+def _run_script(scripts_dir, script_name, args):
+    """Run a Gator script by name, forwarding arguments."""
+    script_path = scripts_dir / script_name
+    if not script_path.exists():
+        print(f"  Error: script not found: {script_name}", file=sys.stderr)
+        print(f"  Looked in: {scripts_dir}", file=sys.stderr)
+        sys.exit(1)
+    result = subprocess.run(
+        [sys.executable, str(script_path)] + args,
+    )
+    sys.exit(result.returncode)
+
+
+# ---------------------------------------------------------------------------
+# Command definitions
+# ---------------------------------------------------------------------------
+
+COMMANDS = {
+    "version":    ("gator-version.py",       "Show Gator version"),
+    "init":       ("gator-init.py",          "Run session-opening procedure"),
+    "pulse":      ("gator-pulse.py",         "Generate strategic operations brief"),
+    "dashboard":  ("gator-dashboard.py",     "Start the governance dashboard"),
+    "audit":      ("gator-audit.py",         "Run governance audit"),
+    "drift":      ("gator-drift.py",         "Check fleet for governance drift"),
+    "fleet":      ("gator-fleet-report.py",  "Fleet status report"),
+}
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="gator",
+        description="Gator — Git-native governance for AI-assisted engineering",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "examples:\n"
+            "  gator version          Show installed version\n"
+            "  gator init             Start a governed session\n"
+            "  gator dashboard        Launch the governance dashboard\n"
+            "  gator pulse            Generate the strategic operations brief\n"
+        ),
+    )
+    parser.add_argument(
+        "--version", "-V",
+        action="version",
+        version=f"%(prog)s {_get_version()}",
+    )
+
+    sub = parser.add_subparsers(dest="command")
+    for cmd_name, (_, help_text) in COMMANDS.items():
+        sub.add_parser(cmd_name, help=help_text, add_help=False)
+
+    args, remaining = parser.parse_known_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+
+    scripts_dir = _find_scripts_dir()
+    if not scripts_dir:
+        print("  Error: Gator scripts directory not found.", file=sys.stderr)
+        print("  Run from a Gator checkout, or install with: pipx install gator-command", file=sys.stderr)
+        sys.exit(1)
+
+    script_name, _ = COMMANDS[args.command]
+    _run_script(scripts_dir, script_name, remaining)
+
+
+def _get_version():
+    """Get version from package metadata or VERSION file."""
+    try:
+        from gator_command import __version__
+        return __version__
+    except ImportError:
+        pass
+    # Fallback: read VERSION file
+    version_file = Path(__file__).resolve().parent.parent.parent / "VERSION"
+    if version_file.exists():
+        return version_file.read_text(encoding="utf-8").strip()
+    return "unknown"
+
+
+if __name__ == "__main__":
+    main()