@homericintelligence/athena-opencode 0.4.4

package/skills/systematic-debugging/scripts/repository_evidence.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""Collect reproducible recent-change and source-pattern evidence."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+if __package__ in {None, ""}:
+    sys.path.insert(0, str(Path(__file__).resolve().parents[3]))
+
+from skills._cli import argument_parser, run_command
+
+EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
+
+
+def run(*arguments: str, accepted_codes: tuple[int, ...] = (0,)) -> str:
+    result = run_command(arguments, capture_output=True, text=True, check=False)
+    if result.returncode not in accepted_codes:
+        raise RuntimeError(result.stderr.strip() or f"{' '.join(arguments)} failed")
+    return result.stdout
+
+
+def main() -> int:
+    parser = argument_parser(description=__doc__)
+    parser.add_argument("pattern")
+    parser.add_argument("--source-root", default=".")
+    arguments = parser.parse_args()
+    try:
+        try:
+            recent_revisions = run(
+                "git", "rev-list", "--max-count=10", "HEAD"
+            ).splitlines()
+        except RuntimeError as error:
+            raise RuntimeError(f"cannot resolve HEAD: {error}") from error
+        if not recent_revisions:
+            raise RuntimeError("cannot resolve HEAD: repository has no commits")
+        recent_commits = run("git", "log", "--oneline", "-10")
+        oldest_parent = run(
+            "git",
+            "rev-parse",
+            "--verify",
+            f"{recent_revisions[-1]}^",
+            accepted_codes=(0, 128),
+        ).strip()
+        recent_range = f"{oldest_parent or EMPTY_TREE}..HEAD"
+        recent_diff = run("git", "diff", "--stat", recent_range)
+        pattern_matches = run(
+            "git",
+            "grep",
+            "--line-number",
+            "-e",
+            arguments.pattern,
+            "--",
+            arguments.source_root,
+            accepted_codes=(0, 1),
+        )
+    except RuntimeError as error:
+        print(error, file=sys.stderr)
+        return 1
+    print(
+        json.dumps(
+            {
+                "pattern_matches": pattern_matches,
+                "recent_commits": recent_commits,
+                "recent_diff": recent_diff,
+                "recent_range": recent_range,
+            },
+            sort_keys=True,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/test-driven-development/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: test-driven-development
+license: BSD-3-Clause
+description: Use when implementing any feature or bugfix, before writing implementation code — enforces RED-GREEN-REFACTOR cycle
+argument-hint: <feature or bugfix description>
+allowed-tools: [Read, Write, Edit, Bash, Grep, Glob]
+---
+
+# Test-Driven Development (TDD)
+
+Why: seeing a focused test fail proves it can detect the missing product
+behavior; seeing it pass proves the smallest implementation satisfies it.
+
+Use Athena's shared [behavior-first testing guidance](../../docs/review/behavior-first-testing.md)
+for good-test/bad-test criteria, determinism, and false-pass checks. Test
+observable product behavior and core contracts, not wording, documentation
+layout, or a private implementation arrangement.
+
+## Use and rule
+
+Use TDD for features, bug fixes, refactoring, and behavior changes. Ask the
+human partner before exempting a throwaway prototype, generated code,
+configuration-only work, or documentation-only wording/layout change. In a
+swarm, the test specialist completes RED before implementation begins.
+
+```text
+NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
+```
+
+If you wrote in-scope implementation first, remove only that newly authored
+work and start with RED. Preserve pre-existing or user-authored work and ask for
+direction when provenance or scope is unclear.
+
+## RED–GREEN–REFACTOR
+
+1. **RED:** Write one minimal, clearly named test for one observable behavior,
+   data contract, security property, or executable artifact outcome. Use real
+   code unless a controlled substitute is needed at a genuine external boundary.
+2. **Verify RED:** Discover the repository's focused test command and run it.
+   The test must fail—not error—for the expected missing behavior. A filtered
+   command must prove it selected a relevant test; C++/CMake tests must be wired
+   to a real build and test target. If the test passes, it covers existing
+   behavior; if it errors, fix the test setup and run it again.
+3. **GREEN:** Write the simplest behaviorally complete code that passes. Do not
+   add speculative features, unrelated refactors, or implementation beyond the
+   test's demonstrated need.
+4. **Verify GREEN:** Run the discovered relevant suite. The new and existing
+   tests must pass without errors or warnings; fix code rather than weakening a
+   test.
+5. **REFACTOR:** After green, remove duplication, clarify names, or extract a
+   helper without adding behavior. Keep tests green, then start the next RED
+   cycle.
+
+For documentation-only changes, use existing Markdown, link, and executable
+example validation. Do not create production code or a text-assertion harness
+to manufacture a RED phase.
+
+## Evidence before completion
+
+Discover commands from `AGENTS.md`, task runners, manifests, lockfiles, and
+required CI; prefer repository-native entry points. Record focused and relevant
+suite, coverage, type, and lint commands when applicable. If they conflict or
+no safe command is discoverable, ask the user rather than borrow another
+repository's command.
+
+Before completion, confirm proportionate coverage for every changed observable
+behavior and bug regression; controlled time, services, randomness, state, and
+mocks where the product requires them; non-empty focused test selection; and
+fresh passing relevant tests, type checks, and lint. Follow the evidence policy
+before claiming success. Use `learn` for a durable testing lesson; its own
+scope and delivery rules determine whether it publishes a PR.
+
+---
+
+_Adapted from [obra/superpowers](https://github.com/obra/superpowers) under the [MIT License](https://github.com/obra/superpowers/blob/main/LICENSE). Copyright (c) 2025 Jesse Vincent._

package/skills/tidy/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: tidy
+license: BSD-3-Clause
+description: Delegate repository branch and worktree cleanup to the dependency-locked Hephaestus tidy command. Use for tidy, cleanup, or rebase requests; fail closed when the trusted automation checkout or required execution capability cannot be prepared.
+argument-hint: "<optional: hephaestus-tidy arguments>"
+allowed-tools: [Bash, Read]
+---
+
+# Tidy through Hephaestus
+
+Use this when the user asks to tidy, clean up, or rebase a repository's local branches or
+worktrees. Athena prepares the trusted automation dependency and delegates the complete operation;
+`hephaestus-tidy` owns discovery, preservation rules, prompts, rebases, removal safeguards, output,
+and the final exit status.
+
+## Inputs
+
+Keep the target repository as the current working directory. Treat every argument supplied to this
+skill as a `hephaestus-tidy` argument and forward it unchanged. When the user wants a preview,
+forward `--dry-run`; do not reinterpret it or add it implicitly.
+
+## Workflow
+
+1. Prepare Hephaestus at `$HOME/.agent_brain/automation` under the canonical
+   [`dependency-resolution` contract](../../docs/dependency-resolution.md). Report the resolved
+   repository, commit SHA, and trust basis. Resolution, authentication, checkout, update,
+   cleanliness, identity, revision-binding, or automatic-fork revalidation failure is blocking.
+2. Keep the target repository as the current working directory. Resolve `scripts/run_tidy.py`
+   against this installed skill directory and invoke that absolute helper path with the resolved
+   automation checkout as its first internal operand, followed by every user argument in its
+   original order and form.
+3. The helper replaces itself with this dependency-locked command vector:
+
+   ```text
+   uv run --project <resolved-automation-checkout> --locked hephaestus-tidy <user-arguments>
+   ```
+
+4. Leave stdin, stdout, and stderr attached. Do not capture, pipe, summarize in place of, answer,
+   retry, or otherwise mediate the command. The user answers any interactive prompt emitted by
+   Hephaestus.
+
+Athena performs no worktree audit, candidate classification, removal, prompt, branch rebase, or
+cleanup safety decision of its own. It never substitutes a `hephaestus-tidy` executable found on
+`PATH` for the dependency-locked command.
+
+## Dependency and capability failures
+
+Authenticated `gh`, Git, and network access are required by dependency preparation. Python 3 and
+`uv` are required to start the locked command. On any missing capability or nonzero command result,
+return the failure unchanged and stop. Do not fall back to a stale checkout, a similarly named
+repository, an ambient executable, or a second cleanup implementation.
+
+## Failed approaches
+
+- Auditing and removing worktrees in Athena duplicated Hephaestus policy and produced a second set
+  of destructive-action prompts.
+- Invoking an ambient `hephaestus-tidy` could bypass the resolved repository and its lockfile.
+- Parsing, normalizing, or reconstructing user arguments changed the delegated CLI contract.
+- Capturing or piping the process could alter interactive behavior, output, signals, or exit status.
+
+## Output
+
+Before execution, report the resolved Hephaestus repository, commit SHA, and trust basis. After
+that, preserve the delegated command's output and terminal result without adding Athena-specific
+worktree classifications or cleanup conclusions.
+
+## Attribution
+
+The cleanup implementation and safeguards are owned by
+[`HomericIntelligence/Hephaestus`](https://github.com/HomericIntelligence/Hephaestus). Athena owns
+only dependency preparation and the tested transport adapter.

package/skills/tidy/scripts/run_tidy.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""Replace this process with the dependency-locked Hephaestus tidy command."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+if __package__ in {None, ""}:
+    sys.path.insert(0, str(Path(__file__).resolve().parents[3]))
+
+from skills._cli import argument_parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    raw_arguments = list(sys.argv[1:] if argv is None else argv)
+    parser = argument_parser(description=__doc__)
+    parser.add_argument("automation_checkout", type=Path)
+    parser.add_argument("arguments", nargs=argparse.REMAINDER)
+    parsed = parser.parse_args(raw_arguments)
+    command = [
+        "uv",
+        "run",
+        "--project",
+        str(parsed.automation_checkout),
+        "--locked",
+        "hephaestus-tidy",
+        *raw_arguments[1:],
+    ]
+    try:
+        os.execvp(command[0], command)
+    except FileNotFoundError as error:
+        missing = error.filename or command[0]
+        print(f"required command unavailable: {missing}", file=sys.stderr)
+        return 127
+    raise RuntimeError("os.execvp returned unexpectedly")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())