hyperflash 1.0.0__tar.gz → 1.1.1__tar.gz

{hyperflash-1.0.0 → hyperflash-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperflash
-Version: 1.0.0
+Version: 1.1.1
 Summary: Universal Engineering Reliability Runtime & Multi-Agent Verification Guardrails
 Author: Virat Ghatge
 License: MIT
@@ -43,7 +43,7 @@ Dynamic: license-file
 
 <br/>
 
-[![PyPI](https://img.shields.io/pypi/v/hyperflash?style=for-the-badge&logo=pypi&color=3775A9)](https://pypi.org/project/hyperflash/)
+[![PyPI - Version](https://img.shields.io/pypi/v/hyperflash?style=for-the-badge&logo=pypi&logoColor=white&color=3776AB)](https://pypi.org/project/hyperflash/)
 [![Stars](https://img.shields.io/github/stars/Virat-Ghatge/hyperflash?style=for-the-badge&logo=github&color=FFD700)](https://github.com/Virat-Ghatge/hyperflash/stargazers)
 [![Forks](https://img.shields.io/github/forks/Virat-Ghatge/hyperflash?style=for-the-badge&logo=github&color=60A5FA)](https://github.com/Virat-Ghatge/hyperflash/network/members)
 [![Issues](https://img.shields.io/github/issues/Virat-Ghatge/hyperflash?style=for-the-badge&color=34D399)](https://github.com/Virat-Ghatge/hyperflash/issues)
@@ -74,6 +74,10 @@ HyperFlash is a **model-agnostic, harness-agnostic engineering reliability runti
 
 Whether you are using fast economy engines (**Gemini 3.8 Flash**, **Claude 3.5 Haiku**, **GPT-4o-mini**) or frontier reasoning models (**Claude 3.7 Sonnet**, **OpenAI o1/o3**, **Gemini 3 Pro / Hydrogen**, **DeepSeek-R1**), HyperFlash guarantees that code modifications are surgical, complete, type-safe, and empirically verified before completion is ever granted.
 
+> [!NOTE]
+> **Origins & Multi-Platform Evolution:**
+> HyperFlash was originally conceived and engineered specifically with **Google Antigravity** in mind to solve the notorious `/boost` token burn, lazy code truncation (`// ... rest of code`), and premature victory hallucinations. Having achieved rock-solid reliability in Antigravity through native lifecycle hooks and permission asymmetry, we are now actively expanding HyperFlash to bring that same disciplined engineering rigor to **all major platforms**—including **OpenCode**, **Claude Code**, **Cursor**, **Windsurf**, and standalone CLI workflows.
+
 ---
 
 ## 🌐 Universal Model & Harness Compatibility
@@ -177,7 +181,7 @@ pip install hyperflash
 Scaffold your preferred IDE or agent harness in 1 second:
 
 ```bash
-# Configure Cursor, Claude Code, Windsurf, Git Hooks, and Antigravity in one command
+# Configure Cursor, Claude Code, Windsurf, Git Hooks, Antigravity, and OpenCode in one command
 hyperflash init
 
 # Or target your specific harness:
@@ -186,6 +190,25 @@ hyperflash init --target claude
 hyperflash init --target windsurf
 hyperflash init --target git
 hyperflash init --target antigravity
+hyperflash init --target opencode
+```
+
+### 🚀 Universal Agent Launcher
+Launch your preferred coding environment with the native HyperFlash agent persona pre-activated:
+
+```bash
+# Launch OpenCode with native HyperFlash agent
+hyperflash launch opencode
+
+# Launch Antigravity terminal session with HyperFlash agent
+hyperflash launch antigravity   # or: hyperflash launch agy
+
+# Launch Claude Code with HyperFlash rules and /hyperflash command
+hyperflash launch claude
+
+# Launch Cursor or Windsurf with HyperFlash agent rules
+hyperflash launch cursor
+hyperflash launch windsurf
 ```
 
 ### 🔌 Universal MCP Server Integration
@@ -227,6 +250,18 @@ HyperFlash features a built-in Model Context Protocol (MCP) server running over
 }
 ```
 
+#### In OpenCode (`opencode.json`):
+```json
+{
+  "mcpServers": {
+    "hyperflash": {
+      "command": "hyperflash",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
 ### Or Clone & Run Local Shell Installer
 If you are developing locally without `pip`:
 
@@ -282,32 +317,59 @@ HyperFlash integrates directly into the Antigravity Desktop IDE and the terminal
 
 ### 2. Claude Code (Anthropic CLI)
 
-You can bring HyperFlash's invariants into Claude Code using project memory and pre/post tool hooks.
-
-#### Step 1: Add HyperFlash Constitution to `CLAUDE.md`
-Add the following to your project's `CLAUDE.md` or `~/.claude/CLAUDE.md`:
+You can bring HyperFlash's invariants into Claude Code using project memory, pre/post tool hooks, and native slash commands.
 
-```markdown
-# HyperFlash Reliability Constitution for Claude Code
+#### Step 1: Automatic Setup via CLI
+```bash
+hyperflash init --target claude
+```
+This automatically configures:
+- `CLAUDE.md`: System reliability constitution.
+- `.claude.json`: Local stdio MCP server for safe patching and AST symbol graphs.
+- `.claude/commands/hyperflash.md`: Dedicated agent slash command.
 
-1. GROUND FIRST: Never call file editing tools on an existing file without calling `View` or `Cat` first in this session.
-2. ZERO CODE ELISION: Never emit `// ... rest of code`, `# ... existing code`, or `TODO: implement`. Every edit must be 100% complete.
-3. CONTRACT BOUNDARY: Only mutate files explicitly discussed and approved for the current task. Do not touch external modules.
-4. EVIDENCE OVER CLAIMS: Never declare a task complete or a bug fixed unless you have executed the project test command (`pytest`, `npm test`, `cargo test`) in this session and observed exit code 0.
-5. CHUNKED DECODE: For files exceeding 200 lines, emit class/function skeletons first, then populate method bodies in surgical 100-150 line diffs.
+#### Step 2: Activate HyperFlash in Claude Code
+Inside any Claude Code terminal session, simply run:
+```text
+/hyperflash
+```
+Or launch Claude Code directly with HyperFlash active:
+```bash
+hyperflash launch claude
 ```
 
-#### Step 2: Wire Pre-Commit Verification
-Run HyperFlash's standalone verification script inside Claude Code:
+#### Step 3: Run Deterministic Verification
+Execute HyperFlash's verification hierarchy directly from Claude Code:
 ```bash
-python -m src.skills.hyperflash.scripts.verify_hierarchy --tier 6
+hyperflash verify --tier 6
 ```
 
 ---
 
 ### 3. OpenCode / OpenHands / SWE-Agent
 
-HyperFlash scripts can be invoked directly inside any autonomous agent container or Python environment:
+OpenCode supports dedicated named agents natively. HyperFlash installs as a first-class persona with custom system prompts and tools.
+
+#### Step 1: Automatic Setup via CLI
+```bash
+hyperflash init --target opencode
+```
+This configures:
+- `OPENCODE.md`: OpenCode engineering constitution.
+- `.opencode/agents/hyperflash.json`: Dedicated agent persona definition.
+- `opencode.json`: Declares `agent: "hyperflash"`, registers agent configuration, and wires the `hyperflash` stdio MCP server.
+
+#### Step 2: Launch OpenCode with HyperFlash Persona
+```bash
+# Direct OpenCode CLI
+opencode --agent hyperflash
+
+# Or via the universal runner
+hyperflash launch opencode
+```
+
+#### Step 3: Custom Agent Harnesses (Python / Containers)
+HyperFlash guardrails can also be evaluated programmatically inside any agent container:
 
 ```python
 # In your custom agent loop or OpenHands execution environment
@@ -331,34 +393,25 @@ def run_hyperflash_guards(tool_call: dict) -> bool:
 
 ### 4. Cursor & Windsurf IDEs
 
-Scaffold full HyperFlash rules and MCP integration with one command:
+HyperFlash delivers always-on rule enforcement and tool capabilities for modern AI-native IDEs.
+
+#### Step 1: Automatic Setup via CLI
 ```bash
-hyperflash init --target cursor   # Configures .cursorrules & .cursor/mcp.json
-hyperflash init --target windsurf # Configures .windsurfrules & .windsurf/mcp.json
+hyperflash init --target cursor   # Configures .cursorrules, .cursor/rules/hyperflash.mdc, .cursor/mcp.json
+hyperflash init --target windsurf # Configures .windsurfrules, .windsurf/rules/hyperflash.md, .windsurf/mcp.json
 ```
 
-Or manually configure your workspace:
-- **Rules file (`.cursorrules` or `.windsurfrules`):**
-```markdown
-# HyperFlash Engineering Rules
-- Always view the entire target file before proposing edits.
-- Never truncate code with comments like `// existing code remains the same`. Write the entire functional block.
-- Always include exhaustive static type annotations on all parameters and return values.
-- Before claiming a task is done, run terminal commands to verify compilation and tests.
-- Emit a `decision:` and `pre_mortem:` YAML block before multi-file edits.
-```
-- **MCP Server (`.cursor/mcp.json` or `.windsurf/mcp.json`):**
-```json
-{
-  "mcpServers": {
-    "hyperflash": {
-      "command": "hyperflash",
-      "args": ["mcp"]
-    }
-  }
-}
+#### Step 2: Launch IDE with HyperFlash
+```bash
+hyperflash launch cursor
+hyperflash launch windsurf
 ```
 
+#### What Gets Configured:
+- **Cursor Rules MDC (`.cursor/rules/hyperflash.mdc`):** Enforces `alwaysApply: true` so Cursor Composer and Agent mode strictly observe the 8 Invariants across all edits.
+- **Windsurf Rules (`.windsurf/rules/hyperflash.md` & `.windsurfrules`):** Guides Cascade Agent with zero-elision and ground-before-mutating constraints.
+- **MCP Integration (`mcp.json`):** Exposes `hyperflash_safe_patch`, `hyperflash_verify`, and `hyperflash_get_symbol_graph` directly to the IDE agent.
+
 ---
 
 ### 5. Git Pre-Commit & CI/CD Quality Gates
@@ -374,7 +427,7 @@ hyperflash init --target git
 ```yaml
 repos:
   - repo: https://github.com/Virat-Ghatge/hyperflash
-    rev: v1.0.0
+    rev: v1.1.1
     hooks:
       - id: hyperflash-zero-elision
       - id: hyperflash-verify
@@ -603,6 +656,14 @@ hyperflash/
 <b>Yes.</b> HyperFlash is completely harness-agnostic. The repository includes configurations, constitutions, and CLI scripts for <b>Claude Code</b>, <b>OpenCode / OpenHands</b>, <b>Cursor</b>, <b>Windsurf</b>, standalone terminal workflows, and Git pre-commit hooks.
 </details>
 
+<details>
+<summary><b>Wasn't HyperFlash originally built for Google Antigravity?</b></summary>
+<br/>
+<b>Yes!</b> HyperFlash was originally created specifically for Google Antigravity to solve real-world autonomous coding frustrations: ungrounded mutations, code truncation, and the heavy token burn of Antigravity's default <code>/boost</code> swarm. 
+<br/><br/>
+However, software engineering reliability is a universal challenge across all AI developer tools. We are actively bringing HyperFlash to the entire ecosystem—supporting <b>OpenCode</b>, <b>Claude Code</b>, <b>Cursor</b>, <b>Windsurf</b>, and custom agent runtimes through our universal <code>hyperflash init</code> CLI and local MCP server.
+</details>
+
 <details>
 <summary><b>How does HyperFlash physically prevent code truncation (`// ... rest of code`)?</b></summary>
 <br/>