MertCapkin-GraphStack 4.5.1__py3-none-any.whl

graphstack/compact/generic.py

@@ -0,0 +1,90 @@
+"""Generic compaction for test runners and unknown commands."""
+
+from __future__ import annotations
+
+import re
+
+from .base import (
+    _DEFAULT_MAX_LINES,
+    dedupe_consecutive,
+    is_critical_line,
+    truncate_preserving_critical,
+)
+
+_PYTEST_SUMMARY_RE = re.compile(
+    r"(?i)=+\s*(FAILURES|ERRORS|short test summary|passed|failed)\s*=+"
+)
+
+
+def compact_pytest(text: str) -> str:
+    lines = text.splitlines()
+    if not lines:
+        return ""
+
+    keep: list[str] = []
+    in_failure_block = False
+    failure_blocks: list[list[str]] = []
+    current_block: list[str] = []
+
+    for line in lines:
+        if _PYTEST_SUMMARY_RE.search(line) or line.startswith("FAILED ") or line.startswith("ERROR "):
+            in_failure_block = True
+        if in_failure_block:
+            current_block.append(line)
+            if line.strip() == "" and len(current_block) > 3:
+                failure_blocks.append(current_block)
+                current_block = []
+                in_failure_block = False
+            continue
+        if is_critical_line(line):
+            keep.append(line)
+        elif "passed" in line.lower() and "failed" in line.lower():
+            keep.append(line)
+
+    if current_block:
+        failure_blocks.append(current_block)
+
+    # Last lines often hold the summary
+    tail = lines[-15:] if len(lines) > 15 else lines
+    for line in tail:
+        if line not in keep and (is_critical_line(line) or "passed" in line.lower()):
+            keep.append(line)
+
+    out: list[str] = []
+    for block in failure_blocks[-5:]:
+        out.extend(block[:40])
+    out.extend(keep)
+    out = dedupe_consecutive(out)
+
+    if len(out) > _DEFAULT_MAX_LINES:
+        out, omitted = truncate_preserving_critical(out)
+        out.append(f"... [{omitted} lines omitted — use: graphstack run --raw -- pytest ...]")
+
+    if not out:
+        return compact_generic(text)
+    return "\n".join(out)
+
+
+def compact_generic(text: str, *, max_lines: int = _DEFAULT_MAX_LINES) -> str:
+    lines = text.splitlines()
+    if not lines:
+        return ""
+
+    # Strip obvious noise (progress bars, download meters)
+    filtered: list[str] = []
+    for line in lines:
+        if re.search(r"[\|/#\-]{4,}.*\d+%", line):
+            continue
+        if re.match(r"^\s*$", line) and filtered and filtered[-1] == "":
+            continue
+        filtered.append(line)
+
+    filtered = dedupe_consecutive(filtered)
+    if len(filtered) <= max_lines:
+        return "\n".join(filtered)
+
+    trimmed, omitted = truncate_preserving_critical(filtered, max_lines=max_lines)
+    trimmed.append(
+        f"... [{omitted} lines omitted — use: graphstack run --raw -- <command> for full output]"
+    )
+    return "\n".join(trimmed)

graphstack/compact/git.py

@@ -0,0 +1,167 @@
+"""Git command output compactors — preserve paths, branch, and diff hunks."""
+
+from __future__ import annotations
+
+import re
+from .base import (
+    _DEFAULT_MAX_LINES,
+    dedupe_consecutive,
+    is_critical_line,
+    truncate_preserving_critical,
+)
+
+_BRANCH_RE = re.compile(r"^On branch (.+)$|^HEAD detached at (.+)$", re.MULTILINE)
+_AHEAD_BEHIND_RE = re.compile(
+    r"Your branch is (ahead of|behind) [^\s]+ by (\d+) commit",
+)
+
+
+def compact_git_status(text: str) -> str:
+    porcelain = _try_porcelain_status(text)
+    if porcelain is not None:
+        return porcelain
+
+    lines = text.splitlines()
+    out: list[str] = []
+    for line in lines:
+        if _BRANCH_RE.match(line) or _AHEAD_BEHIND_RE.search(line):
+            out.append(line.strip())
+        elif line.startswith("nothing to commit"):
+            out.append(line.strip())
+        elif line.strip().startswith(("modified:", "new file:", "deleted:", "renamed:")):
+            out.append(line.strip())
+        elif line.strip() and (
+            line.startswith("\t") or line.startswith("  ") or ":" in line[:40]
+        ):
+            out.append(line.strip())
+
+    if not out:
+        return text.strip()
+
+    grouped = dedupe_consecutive(out)
+    if len(grouped) > _DEFAULT_MAX_LINES:
+        grouped, omitted = truncate_preserving_critical(grouped)
+        grouped.append(f"... [{omitted} lines omitted — use: graphstack run --raw -- git status]")
+    return "\n".join(grouped)
+
+
+def _try_porcelain_status(text: str) -> str | None:
+    lines = [ln for ln in text.splitlines() if ln.strip()]
+    if not lines:
+        return None
+    if not all(len(ln) >= 3 and ln[2] in (" ", "?") for ln in lines if not ln.startswith("#")):
+        # Heuristic: porcelain lines are XY + space + path
+        xy_lines = [ln for ln in lines if len(ln) >= 4 and ln[2] == " "]
+        if len(xy_lines) < len(lines) * 0.5:
+            return None
+
+    branch_lines = [ln[2:].strip() for ln in lines if ln.startswith("## ")]
+    staged: list[str] = []
+    unstaged: list[str] = []
+    untracked: list[str] = []
+
+    for line in lines:
+        if line.startswith("#") or line.startswith("##"):
+            continue
+        if len(line) < 4:
+            continue
+        xy, path = line[:2], line[3:].strip()
+        if xy == "??":
+            untracked.append(path)
+        elif xy[0] != " ":
+            staged.append(path)
+        elif xy[1] != " ":
+            unstaged.append(path)
+
+    parts: list[str] = []
+    if branch_lines:
+        parts.append(branch_lines[0])
+    if staged:
+        parts.append(f"staged ({len(staged)}): " + ", ".join(_limit_paths(staged)))
+    if unstaged:
+        parts.append(f"unstaged ({len(unstaged)}): " + ", ".join(_limit_paths(unstaged)))
+    if untracked:
+        parts.append(f"untracked ({len(untracked)}): " + ", ".join(_limit_paths(untracked)))
+    if not parts:
+        return None
+    return "\n".join(parts)
+
+
+def _limit_paths(paths: list[str], limit: int = 40) -> list[str]:
+    if len(paths) <= limit:
+        return paths
+    head = paths[:limit]
+    head.append(f"... +{len(paths) - limit} more")
+    return head
+
+
+def compact_git_diff(text: str, *, max_lines: int = 150) -> str:
+    lines = text.splitlines()
+    if len(lines) <= max_lines:
+        return text.strip()
+
+    # Always keep file headers and hunk headers; preserve +/- lines in each hunk
+    kept: list[str] = []
+    hunk_lines: list[str] = []
+    omitted = 0
+
+    def flush_hunk() -> None:
+        nonlocal omitted
+        if not hunk_lines:
+            return
+        if len(kept) + len(hunk_lines) > max_lines and len(hunk_lines) > 30:
+            # Keep hunk header + first/last change lines
+            header = [hunk_lines[0]] if hunk_lines[0].startswith("@@") else []
+            changes = [
+                ln
+                for ln in hunk_lines
+                if ln.startswith(("+", "-")) and not ln.startswith(("+++", "---"))
+            ]
+            body = header + changes[:12] + (["..."] if len(changes) > 12 else []) + changes[-6:]
+            kept.extend(body)
+            omitted += len(hunk_lines) - len(body)
+        else:
+            kept.extend(hunk_lines)
+
+    for line in lines:
+        if line.startswith("diff --git") or line.startswith("--- ") or line.startswith("+++ "):
+            flush_hunk()
+            hunk_lines = []
+            kept.append(line)
+        elif line.startswith("@@"):
+            flush_hunk()
+            hunk_lines = [line]
+        else:
+            hunk_lines.append(line)
+    flush_hunk()
+
+    if omitted:
+        kept.append(
+            f"... [{omitted} diff lines omitted — use: graphstack run --raw -- git diff]"
+        )
+    return "\n".join(kept)
+
+
+def compact_git_log(text: str, *, max_entries: int = 30) -> str:
+    lines = [ln for ln in text.splitlines() if ln.strip()]
+    if len(lines) <= max_entries:
+        return "\n".join(lines)
+
+    compacted: list[str] = []
+    for line in lines[:max_entries]:
+        if re.match(r"^[0-9a-f]{7,40}\s", line):
+            compacted.append(line)
+        elif re.match(r"^commit [0-9a-f]{40}", line):
+            continue  # skip full commit header blocks when verbose
+        elif line.startswith("Author:") or line.startswith("Date:"):
+            continue
+        elif is_critical_line(line):
+            compacted.append(line)
+        else:
+            compacted.append(line[:120])
+
+    compacted.append(
+        f"... [{len(lines) - max_entries} older entries omitted — "
+        "use: graphstack run --raw -- git log ...]"
+    )
+    return "\n".join(compacted)

graphstack/compact/registry.py

@@ -0,0 +1,47 @@
+"""Route argv to the right compactor."""
+
+from __future__ import annotations
+
+from .base import CompactResult, safe_compact
+from .generic import compact_generic, compact_pytest
+from .git import compact_git_diff, compact_git_log, compact_git_status
+
+
+def _normalize_argv(argv: list[str]) -> list[str]:
+    return [a for a in argv if a]
+
+
+def compact_command_output(argv: list[str], raw_stdout: str, raw_stderr: str = "") -> CompactResult:
+    """Compact *raw_stdout* for the given command argv. stderr is appended verbatim."""
+    argv = _normalize_argv(argv)
+    combined_for_match = " ".join(argv).lower()
+    stdout = raw_stdout or ""
+
+    if not argv:
+        return CompactResult(stdout.rstrip("\n"), "passthrough", fell_back_to_raw=True)
+
+    name = argv[0].lower()
+    sub = argv[1].lower() if len(argv) > 1 else ""
+
+    if name in ("git", "git.exe") and sub == "status":
+        compacted = compact_git_status(stdout)
+        result = safe_compact(stdout, "git-status", compacted)
+    elif name in ("git", "git.exe") and sub == "diff":
+        compacted = compact_git_diff(stdout)
+        result = safe_compact(stdout, "git-diff", compacted)
+    elif name in ("git", "git.exe") and sub in ("log", "reflog"):
+        compacted = compact_git_log(stdout)
+        result = safe_compact(stdout, "git-log", compacted)
+    elif name in ("pytest", "pytest.exe") or "pytest" in combined_for_match:
+        compacted = compact_pytest(stdout)
+        result = safe_compact(stdout, "pytest", compacted)
+    else:
+        compacted = compact_generic(stdout)
+        result = safe_compact(stdout, "generic", compacted)
+
+    if raw_stderr.strip():
+        suffix = raw_stderr.rstrip("\n")
+        text = result.text + ("\n" if result.text else "") + suffix
+        return CompactResult(text, result.used_compactor, result.fell_back_to_raw)
+
+    return result

graphstack/constants.py

@@ -0,0 +1,38 @@
+"""Path and configuration constants used across the package.
+
+Paths are resolved relative to the *current working directory* (the project
+root) at call time — never module import time. This keeps the package
+testable in temporary directories.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+HANDOFF_DIR = Path("handoff")
+BOARD_DIR = HANDOFF_DIR / "board"
+TODO_DIR = BOARD_DIR / "todo"
+DOING_DIR = BOARD_DIR / "doing"
+DONE_DIR = BOARD_DIR / "done"
+
+GRAPHIFY_OUT = Path("graphify-out")
+GRAPH_REPORT = GRAPHIFY_OUT / "GRAPH_REPORT.md"
+GRAPH_JSON = GRAPHIFY_OUT / "graph.json"
+GRAPH_HTML = GRAPHIFY_OUT / "graph.html"
+
+STATE_JSON = HANDOFF_DIR / "STATE.json"
+GATE_OFF_FILE = HANDOFF_DIR / ".gate-off"
+
+# Paths that never count as "code" for the process gate. Anything else
+# (plus root-level *.md files, handled in gate.is_code_path) is gated.
+NON_CODE_PREFIXES = (
+    "handoff/",
+    "graphify-out/",
+    ".cursor/",
+    ".claude/",
+)
+
+STALE_GRAPH_HOURS = 24
+
+# Required keys for GNAP board task JSON files (see handoff/board/README.md).
+TASK_REQUIRED_KEYS = ("id", "title", "status", "created_at")