code-puppy-core-plugins 0.0.2__py3-none-any.whl

code_puppy_core_plugins/flux_bootstrap/bundled/commands/flux/tests.md

@@ -0,0 +1,155 @@
+---
+name: tests
+description: Run the test suite, fix regressions introduced by this branch, and leave pre-existing failures untouched
+argument-hint: additional_instructions
+---
+
+# RUN & FIX TESTS
+
+**Argument:** `$ARGUMENTS` (optional additional instructions, e.g. "address all failing tests including pre-existing")
+
+Run the project's test suite, fix only regressions introduced by this branch, and leave pre-existing failures untouched.
+
+If `$ARGUMENTS` contains additional instructions, apply them — they override default behavior (e.g. fix pre-existing failures too, focus on specific test files).
+
+## STEP 1: Setup
+
+```bash
+FLUX_ROOT="${FLUX_ROOT:-$HOME/.flux}"
+FLUX_DIR=$(printf '%s' "$(pwd -P)" | tr -cs 'a-zA-Z0-9' '-')
+FLUX_BASE="$FLUX_ROOT/$FLUX_DIR"
+CONFIG_FILE="$FLUX_BASE/config.env"
+mkdir -p "$FLUX_BASE/todo" "$FLUX_BASE/done" "$FLUX_BASE/review" "$FLUX_BASE/research"
+```
+
+Source config to get `TEST_CMD`:
+
+```bash
+source "$CONFIG_FILE" 2>/dev/null
+echo "TEST_CMD: ${TEST_CMD:-<not set>}"
+```
+
+If `TEST_CMD` is empty or config file is missing:
+
+```
+Error: TEST_CMD is not configured.
+Run /flux/config to set your test command.
+```
+
+Stop.
+
+## STEP 2: Establish baseline (pre-existing failures)
+
+Find the merge base with the default branch to identify which tests were already failing before this branch's changes:
+
+```bash
+DEFAULT_BRANCH=$(git remote show origin 2>/dev/null | grep 'HEAD branch' | awk '{print $NF}' || echo "main")
+MERGE_BASE=$(git merge-base HEAD "origin/$DEFAULT_BRANCH" 2>/dev/null)
+echo "MERGE_BASE: $MERGE_BASE"
+```
+
+Run the test suite against the merge base in a temporary worktree to record pre-existing failures:
+
+```bash
+WORKTREE_DIR=$(mktemp -d)
+git worktree add "$WORKTREE_DIR" "$MERGE_BASE" --detach 2>/dev/null
+```
+
+If worktree creation fails (e.g. no network, shallow clone), skip baseline and assume all failures are regressions — note this clearly in output.
+
+If worktree created: run `$TEST_CMD` inside it, capture failing test names → `BASELINE_FAILURES`. Then clean up:
+
+```bash
+git worktree remove "$WORKTREE_DIR" --force 2>/dev/null
+```
+
+## STEP 3: Run tests on current branch
+
+```bash
+eval "$TEST_CMD" 2>&1
+```
+
+Capture exit code and full output.
+
+- **All tests pass** → print `✅ All tests pass.` and skip to STEP 6.
+- **Failures found** → continue to STEP 4.
+
+## STEP 4: Classify failures
+
+For each failing test, classify it:
+
+| Classification   | Criteria                                                   | Action   |
+| ---------------- | ---------------------------------------------------------- | -------- |
+| **Regression**   | Was passing at merge base (not in `BASELINE_FAILURES`)     | Fix it   |
+| **Pre-existing** | Was already failing at merge base (in `BASELINE_FAILURES`) | Leave it |
+| **Unknown**      | Baseline unavailable                                       | Fix it   |
+
+Print a summary table:
+
+```
+Test Results
+────────────────────────────────────────
+  Total failures:    N
+  Regressions:       R  ← will fix
+  Pre-existing:      P  ← will skip
+  Unknown:           U  ← will fix
+────────────────────────────────────────
+```
+
+If there are no regressions or unknowns → print `✅ No regressions introduced by this branch.` and skip to STEP 6.
+
+## STEP 5: Fix regressions
+
+Fix regressions one at a time. For each:
+
+1. Read the failing test and the source it exercises
+2. Determine root cause: did the feature change break the test, or does the test need updating to match intentional new behavior?
+3. Apply the minimal fix — either in source or in the test file
+4. Do NOT expand test scope or add new test cases
+5. Do NOT touch pre-existing failures
+
+After fixing all regressions, re-run:
+
+```bash
+eval "$TEST_CMD" 2>&1
+```
+
+Repeat fix → re-run cycle until all regressions pass (max 3 cycles). If still failing after 3 cycles, stop and report:
+
+```
+⚠️  Could not fix the following regressions after 3 attempts:
+  - <test name>: <last error>
+
+Remaining pre-existing failures (not touched):
+  - <test name>
+
+Please review manually.
+```
+
+## STEP 6: Final summary
+
+Print:
+
+```
+Test Suite Summary
+────────────────────────────────────────
+  ✅ Regressions fixed:   R
+  ⏭  Pre-existing skipped: P
+  ❌ Unresolved:           U
+────────────────────────────────────────
+```
+
+If `U > 0`, recommend the user review those manually before committing.
+
+## HARD CONSTRAINT
+
+`/flux/tests` MUST NOT use `git commit`, `git push`, `git stash`, `git checkout`, or `git branch`. Only `git merge-base`, `git worktree`, and `git remote` are permitted. MUST NOT modify source files beyond the minimal fix required to resolve a regression. MUST NOT touch pre-existing failures. MUST NOT add new test cases or expand test scope.
+
+## Propose next step
+
+Then propose the next step: `/flux/commit` (include arguments if needed).
+
+Valid `//flux` commands: `/flux/config`, `/flux/new`, `/flux/ask`, `/flux/split`, `/flux/aug`, `/flux/exec`, `/flux/qa`, `/flux/tests`, `/flux/commit`, `/flux/create-pr`, `/flux/review`, `/flux/address-feedback`, `/flux/status`, `/flux/auto-pilot`, `/flux/rebase`. Do NOT suggest any command not on this list.
+
+=================
+$ARGUMENTS

code_puppy_core_plugins/flux_bootstrap/bundled/scripts/flux_about.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""Render the /flux/about overview using Rich's markdown renderer.
+
+This is the deterministic, AI-free renderer for /flux/about. The previous
+hand-rolled ANSI version was rough on tables (column widths didn't account
+for ANSI escapes around cell contents). Rich does the heavy lifting properly:
+real tables, syntax-highlighted code fences, headings, bullets -- all aligned.
+
+Single source of truth: the overview text lives in about.md. We read it at
+runtime, strip the YAML frontmatter + the AI-only preamble, normalize the
+wibey //cmd refs to /cmd, and hand the rest to ``rich.markdown.Markdown``.
+
+Usage:
+  flux_about.py [--source PATH] [--width N] [--no-color]
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import sys
+from pathlib import Path
+
+from rich.console import Console
+from rich.markdown import Markdown
+
+
+def _default_source() -> str:
+    """Resolve about.md under code-puppy's (XDG-aware) config dir.
+
+    Runs inside the code-puppy venv, so importing the canonical resolver is the
+    single source of truth for the config location -- honoring XDG overrides
+    instead of assuming a hard-coded ~/.code_puppy. Falls back to the legacy
+    layout only if that import fails (e.g. run standalone).
+    """
+    try:
+        from code_puppy.config import CONFIG_DIR
+
+        return os.path.join(CONFIG_DIR, "commands", "flux", "about.md")
+    except Exception:
+        return os.path.join(
+            os.path.expanduser("~"), ".code_puppy", "commands", "flux", "about.md"
+        )
+
+
+DEFAULT_SOURCE = _default_source()
+DEFAULT_WIDTH = 120  # most modern terminals are at least this wide
+
+# YAML frontmatter block at the top of the file
+FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---\s*\n", re.DOTALL)
+# Wibey //cmd -> /cmd, URL-safe (won't touch https://, example.com//, etc.)
+SLASH_CMD_RE = re.compile(r"(?<![:\w/])//(?=\w)")
+# The AI instruction preamble we skip when rendering directly
+PREAMBLE_RE = re.compile(r"^Output the following overview exactly")
+
+
+def extract_body(raw: str) -> str:
+    """Strip YAML frontmatter and normalize //cmd -> /cmd."""
+    body = FRONTMATTER_RE.sub("", raw, count=1).strip()
+    return SLASH_CMD_RE.sub("/", body)
+
+
+def drop_ai_preamble(body: str) -> str:
+    """Skip the 'Output the following overview exactly...' block + its --- rule.
+
+    The preamble exists solely to instruct an LLM; when a script is doing the
+    rendering it's just noise. If the preamble isn't present (someone edited
+    it out) the body is returned unchanged.
+    """
+    lines = body.splitlines()
+    out: list[str] = []
+    skipping = False
+    for line in lines:
+        if not skipping and PREAMBLE_RE.match(line):
+            skipping = True
+            continue
+        if skipping:
+            # The preamble ends at the first standalone --- horizontal rule
+            if line.strip() == "---":
+                skipping = False
+            continue
+        out.append(line)
+    return "\n".join(out).strip()
+
+
+def resolve_width(cli_width: int | None) -> int:
+    """CLI flag wins; else $COLUMNS; else our DEFAULT_WIDTH."""
+    if cli_width and cli_width > 0:
+        return cli_width
+    env_cols = os.environ.get("COLUMNS")
+    if env_cols and env_cols.isdigit() and int(env_cols) > 0:
+        return int(env_cols)
+    return DEFAULT_WIDTH
+
+
+def force_utf8_stdout() -> None:
+    """Reconfigure stdout to UTF-8 so emoji survive legacy Windows codepages.
+
+    Under the exec runner the env already forces UTF-8 (PYTHONIOENCODING);
+    this covers standalone runs in a cp1252 console, where printing a single
+    emoji would otherwise raise UnicodeEncodeError. Best-effort by design --
+    these scripts must never crash on an IO quirk. (Duplicated across the
+    flux_* scripts on purpose: each is a standalone, dependency-free file.)
+    """
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+
+def main(argv: list[str] | None = None) -> int:
+    force_utf8_stdout()
+    parser = argparse.ArgumentParser(description="Render /flux/about overview")
+    parser.add_argument(
+        "--source",
+        default=DEFAULT_SOURCE,
+        help=f"Path to about.md (default: {DEFAULT_SOURCE})",
+    )
+    parser.add_argument(
+        "--width",
+        type=int,
+        default=None,
+        help=f"Render width in cols (default: $COLUMNS or {DEFAULT_WIDTH})",
+    )
+    parser.add_argument("--no-color", action="store_true", help="Disable ANSI color")
+    args = parser.parse_args(argv)
+
+    source = Path(args.source).expanduser()
+    if not source.is_file():
+        print(f"(about.md not found at {source})")
+        return 1
+
+    raw = source.read_text(encoding="utf-8", errors="replace")
+    cleaned = drop_ai_preamble(extract_body(raw))
+
+    # force_terminal=True makes Rich emit ANSI to our piped stdout (the exec runner
+    # captures it); legacy_windows=False stays off the win32 LegacyWindowsTerm path,
+    # which both loses that ANSI and crashes encoding emoji on cp1252.
+    console = Console(
+        force_terminal=True,
+        legacy_windows=False,
+        color_system=None if args.no_color else "truecolor",
+        width=resolve_width(args.width),
+        no_color=args.no_color,
+        # Avoid stripping the user's content when stdout isn't a real TTY.
+        soft_wrap=False,
+    )
+    console.print(Markdown(cleaned))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code_puppy_core_plugins/flux_bootstrap/bundled/scripts/flux_cheatsheet.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+"""Render the //flux cheatsheet (pipeline flows) colorized for the terminal.
+
+This is the code-puppy equivalent of Wibey's native cheatsheet panel. Wibey
+shows clickable PIPELINE A/B/C/D tabs; code-puppy can't host interactive tabs,
+so this prints all pipelines stacked (or one, via --pipeline).
+
+SINGLE SOURCE OF TRUTH: the pipeline definitions are parsed at runtime from
+`pipeline.md` in the flux _docs directory. Editing that doc changes this output
+automatically -- nothing is hardcoded here except presentation.
+
+Wibey writes commands as `/flux/<cmd>`; code-puppy's namespaced slash commands
+use a single leading slash, so every command is normalized to `/flux/<cmd>`
+before display -- exactly what a code-puppy user types to run it.
+
+The flux _docs directory defaults to code-puppy's config dir (XDG-aware) rather
+than any hard-coded home path; ``--docs`` overrides it. The command wiring
+passes it explicitly via a ``{command:flux/_docs}`` token.
+
+Usage:
+  flux_cheatsheet.py [--docs DIR] [--pipeline A|B|C|D] [--no-color]
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import sys
+from pathlib import Path
+
+# --- ANSI palette -----------------------------------------------------------
+RESET = "\033[0m"
+MAGENTA = "\033[1;35m"
+CYAN = "\033[1;36m"
+GREEN = "\033[32m"
+WHITE = "\033[1;37m"
+GREY = "\033[90m"
+
+FRAKTUR_F = "\U0001d571"  # mathematical bold fraktur capital F
+
+
+def _default_docs() -> str:
+    """Resolve the flux _docs dir under code-puppy's (XDG-aware) config dir.
+
+    Runs inside the code-puppy venv, so importing the canonical resolver is the
+    single source of truth. Falls back to the legacy ~/.code_puppy layout only
+    if that import somehow fails (e.g. run standalone).
+    """
+    try:
+        from code_puppy.config import CONFIG_DIR
+
+        return os.path.join(CONFIG_DIR, "commands", "flux", "_docs")
+    except Exception:
+        return os.path.join(
+            os.path.expanduser("~"), ".code_puppy", "commands", "flux", "_docs"
+        )
+
+
+DEFAULT_DOCS = _default_docs()
+
+# matches `/flux/`, `/flux/`, etc. -> we normalize to `/flux/` (the single-slash
+# namespaced command code-puppy users actually type).
+SLASH_CMD = re.compile(r"/+flux/")
+PIPELINE_HEADING = re.compile(r"^##\s+PIPELINE\s+([A-Za-z0-9]+)\s*:")
+
+
+class Theme:
+    def __init__(self, enabled: bool) -> None:
+        self.enabled = enabled
+
+    def __call__(self, code: str, text: str) -> str:
+        return f"{code}{text}{RESET}" if self.enabled else text
+
+
+def strip_slashes(line: str) -> str:
+    """`/flux/new` -> `/flux/new`, `/flux/review <PR#>` -> `/flux/review <PR#>`.
+
+    Collapses any run of leading slashes to the single-slash namespaced form
+    code-puppy dispatches (``/flux/<cmd>``).
+    """
+    return SLASH_CMD.sub("/flux/", line)
+
+
+def parse_pipelines(md_text: str) -> list[tuple[str, str, list[str]]]:
+    """Return [(letter, description, [flow_line, ...]), ...] in document order."""
+    lines = md_text.splitlines()
+    pipelines: list[tuple[str, str, list[str]]] = []
+
+    i = 0
+    n = len(lines)
+    while i < n:
+        m = PIPELINE_HEADING.match(lines[i])
+        if not m:
+            i += 1
+            continue
+        letter = m.group(1).upper()
+        i += 1
+
+        # find the description: first meaningful line before the code fence
+        description = ""
+        while i < n and not PIPELINE_HEADING.match(lines[i]):
+            stripped = lines[i].strip()
+            if stripped.startswith("```"):
+                break
+            if stripped and stripped != "---" and not stripped.startswith("#"):
+                description = stripped
+                i += 1
+                break
+            i += 1
+
+        # find and capture the first fenced code block = the flow
+        flow: list[str] = []
+        while i < n and not PIPELINE_HEADING.match(lines[i]):
+            if lines[i].strip().startswith("```"):
+                i += 1  # enter the fence
+                while i < n and not lines[i].strip().startswith("```"):
+                    flow.append(lines[i])
+                    i += 1
+                i += 1  # exit the fence
+                break
+            i += 1
+
+        # trim leading/trailing blank lines inside the flow
+        while flow and not flow[0].strip():
+            flow.pop(0)
+        while flow and not flow[-1].strip():
+            flow.pop()
+
+        pipelines.append((letter, description, flow))
+    return pipelines
+
+
+def render_flow_line(raw: str, theme: Theme) -> str:
+    """Colorize one flow line: comments dim, command flow green, slashes stripped."""
+    if not raw.strip():
+        return ""
+    if raw.strip().startswith("#"):
+        # keep the comment's indentation, dim the text
+        return theme(GREY, strip_slashes(raw))
+    return theme(GREEN, strip_slashes(raw))
+
+
+def render(pipelines: list[tuple[str, str, list[str]]], theme: Theme) -> str:
+    width = 60
+    out: list[str] = []
+    out.append(theme(MAGENTA, f"{FRAKTUR_F} FLUX CHEATSHEET"))
+    out.append(theme(MAGENTA, "\u2550" * width))
+
+    for idx, (letter, desc, flow) in enumerate(pipelines):
+        if idx > 0:
+            out.append("")
+            out.append(theme(GREY, "\u2500" * width))
+        out.append("")
+        out.append(theme(CYAN, f"PIPELINE {letter}"))
+        if desc:
+            out.append(theme(WHITE, desc))
+        out.append("")
+        for line in flow:
+            out.append(render_flow_line(line, theme))
+
+    out.append("")
+    out.append(theme(MAGENTA, "\u2550" * width))
+    return "\n".join(out)
+
+
+def force_utf8_stdout() -> None:
+    """Reconfigure stdout to UTF-8 so emoji survive legacy Windows codepages.
+
+    Under the exec runner the env already forces UTF-8 (PYTHONIOENCODING);
+    this covers standalone runs in a cp1252 console, where printing a single
+    emoji or box-drawing glyph would otherwise raise UnicodeEncodeError.
+    Best-effort by design -- these scripts must never crash on an IO quirk.
+    (Duplicated across the flux_* scripts on purpose: each is a standalone,
+    dependency-free file.)
+    """
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+
+def main(argv: list[str] | None = None) -> int:
+    force_utf8_stdout()
+    parser = argparse.ArgumentParser(description="Render //flux cheatsheet panel")
+    parser.add_argument("--docs", default=DEFAULT_DOCS, help="flux _docs directory")
+    parser.add_argument(
+        "--pipeline",
+        default=None,
+        help="Show only one pipeline (A, B, C, or D)",
+    )
+    parser.add_argument(
+        "pipeline_pos",
+        nargs="?",
+        default=None,
+        help="Optional positional pipeline filter (a/b/c/d); overrides --pipeline.",
+    )
+    parser.add_argument("--no-color", action="store_true", help="Disable ANSI color")
+    args = parser.parse_args(argv)
+
+    # Positional pipeline arg (e.g. `flux_cheatsheet.py a`) wins over --pipeline
+    # so command-line callers don't have to remember the flag name.
+    selected_pipeline = args.pipeline_pos or args.pipeline
+    if selected_pipeline is not None:
+        normalized = selected_pipeline.strip().upper()
+        if normalized not in {"A", "B", "C", "D"}:
+            parser.error(
+                f"invalid pipeline: {selected_pipeline!r} (choose from A, B, C, D)"
+            )
+        args.pipeline = normalized
+
+    docs_dir = Path(args.docs).expanduser()
+    pipeline_md = docs_dir / "pipeline.md"
+
+    # The exec runner pipes stdout + injects FORCE_COLOR=1 (see _run_exec_directive), so
+    # color stays on despite isatty()==False. Keep the FORCE_COLOR branch so the
+    # cheatsheet doesn't silently go monochrome under the runner.
+    color_on = not args.no_color and (
+        sys.stdout.isatty() or os.environ.get("FORCE_COLOR")
+    )
+    theme = Theme(bool(color_on))
+
+    if not pipeline_md.is_file():
+        print(theme(GREY, f"(pipeline doc not found at {pipeline_md})"))
+        return 1
+
+    pipelines = parse_pipelines(
+        pipeline_md.read_text(encoding="utf-8", errors="replace")
+    )
+
+    if args.pipeline:
+        # Already validated + normalized above
+        want = args.pipeline
+        pipelines = [p for p in pipelines if p[0] == want]
+        if not pipelines:
+            print(theme(GREY, f"(no PIPELINE {want} found)"))
+            return 1
+
+    if not pipelines:
+        print(theme(GREY, "(no pipelines found in pipeline.md)"))
+        return 1
+
+    print(render(pipelines, theme))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())