claude-company 0.1.0

package/.claude/hooks/guard_commit.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""PreToolUse (Bash): gate git commit / merge / push commands.
+
+  - push to protected branch (main/master), explicit or bare push while on it:
+    BLOCK (owner-only).
+  - commit / merge: require a green, fresh, valid gates.status stamp. If
+    gates.config is missing or has zero gates, ALLOW + log BYPASS. If the
+    active task is a hotfix, ALLOW + log BYPASS.
+  - everything else: allow.
+
+Fails open on any internal error.
+"""
+
+import os
+import re
+import shlex
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import _common as c  # noqa: E402
+
+HOOK = "guard_commit"
+PROTECTED = {"main", "master"}
+
+
+def segments(command):
+    parts = re.split(r"&&|\|\||;|\|", command)
+    return [p.strip() for p in parts if p.strip()]
+
+
+def git_subcmd(segment):
+    """Return (subcommand, args) for a `git ...` segment, else (None, [])."""
+    try:
+        toks = shlex.split(segment)
+    except Exception:
+        toks = segment.split()
+    if not toks or toks[0] != "git":
+        return None, []
+    i = 1
+    while i < len(toks) and toks[i].startswith("-"):
+        i += 1
+    if i >= len(toks):
+        return None, []
+    return toks[i], toks[i + 1:]
+
+
+def push_targets_protected(root, args):
+    non_opt = [a for a in args if not a.startswith("-")]
+    # first non-option is the remote; the rest are refspecs
+    refspecs = non_opt[1:]
+    for ref in refspecs:
+        dst = ref.split(":")[-1]
+        if dst in PROTECTED:
+            return True
+    if not refspecs:
+        cur = c.current_branch(root)
+        if cur in PROTECTED:
+            return True
+    return False
+
+
+def main():
+    payload = c.read_stdin_json()
+    if payload is None:
+        sys.exit(0)
+    if payload.get("tool_name") != "Bash":
+        sys.exit(0)
+
+    root = c.project_root(payload)
+    command = (payload.get("tool_input") or {}).get("command") or ""
+    if not command:
+        sys.exit(0)
+
+    try:
+        for seg in segments(command):
+            sub, args = git_subcmd(seg)
+            if sub is None:
+                continue
+
+            if sub == "push":
+                if push_targets_protected(root, args):
+                    c.block(
+                        root, HOOK, "git push", "protected branch push",
+                        "BLOCKED: push to a protected branch (main/master) is "
+                        "owner-only. Open a PR or ask the owner to push.",
+                    )
+                continue
+
+            if sub in ("commit", "merge"):
+                task = c.active_task(root)
+                if isinstance(task, dict) and task.get("type") == "hotfix":
+                    c.log_bypass(root, HOOK, "git " + sub, "hotfix mode")
+                    continue
+                cfg = c.gates_config(root)
+                if not isinstance(cfg, dict) or not cfg.get("gates"):
+                    c.log_bypass(
+                        root, HOOK, "git " + sub, "no gates configured"
+                    )
+                    continue
+                ok, reason = c.check_stamp(root)
+                if not ok:
+                    c.block(
+                        root, HOOK, "git " + sub, reason,
+                        "BLOCKED: git {} requires green, fresh gates. {}.\n"
+                        "Fix: run `bash company/run-gates.sh` until green, "
+                        "then retry.\n"
+                        "If company/gates.config still has only CONFIGURE-ME "
+                        "placeholders, run `python3 "
+                        ".claude/hooks/gates_detect.py --write` first to "
+                        "auto-configure real gates, then rerun the "
+                        "suite.".format(sub, reason),
+                    )
+                continue
+    except SystemExit:
+        raise
+    except Exception:
+        sys.exit(0)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/.claude/hooks/guard_frozen.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""PreToolUse (Edit|Write|MultiEdit): block edits to frozen surfaces.
+
+Frozen surfaces are declared in company/frozen-surfaces.json. When that file is
+missing only the hardcoded `always` defaults apply. Also blocks edits to
+git-TRACKED files under any migrations/ or alembic/versions/ directory (a new,
+untracked migration stays editable; on git uncertainty we treat the file as
+tracked and block). Fails open on any internal error.
+"""
+
+import fnmatch
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import _common as c  # noqa: E402
+
+HOOK = "guard_frozen"
+
+ALWAYS_DEFAULTS = [
+    ".env",
+    ".env.*",
+    "*.lock",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "poetry.lock",
+    "Cargo.lock",
+    "company/state/gates.status",
+    "company/state/adherence.log",
+]
+
+ENV_ALLOW_SUFFIXES = (".example", ".sample", ".template")
+
+CR_NOTE = (
+    "Frozen surfaces change only through the change-request protocol "
+    "(company/change-requests/), never a local edit. If this change is "
+    "genuinely needed, file a CR: copy company/templates/CR-TEMPLATE.md to "
+    "company/change-requests/CR-<n>-<slug>.md and surface it in your report. "
+    "The CEO applies approved CRs."
+)
+
+
+def load_config(root):
+    cfg = c.read_json_file(os.path.join(root, "company", "frozen-surfaces.json"))
+    surfaces = []
+    always = list(ALWAYS_DEFAULTS)
+    if isinstance(cfg, dict):
+        for s in cfg.get("surfaces", []) or []:
+            if isinstance(s, dict) and s.get("pattern"):
+                surfaces.append(s)
+        extra = cfg.get("always")
+        if isinstance(extra, list):
+            for pat in extra:
+                if pat not in always:
+                    always.append(pat)
+    return surfaces, always
+
+
+def matches(pattern, rel, base):
+    return fnmatch.fnmatch(rel, pattern) or fnmatch.fnmatch(base, pattern)
+
+
+def main():
+    payload = c.read_stdin_json()
+    if payload is None:
+        sys.exit(0)
+    if payload.get("tool_name") not in ("Edit", "Write", "MultiEdit"):
+        sys.exit(0)
+
+    root = c.project_root(payload)
+    tool_input = payload.get("tool_input") or {}
+    file_path = tool_input.get("file_path") or ""
+    if not file_path:
+        sys.exit(0)
+
+    try:
+        rel = c.rel_path(root, file_path)
+        base = os.path.basename(rel) or os.path.basename(file_path)
+
+        # Documented placeholder env files are always editable.
+        if base.startswith(".env") and base.endswith(ENV_ALLOW_SUFFIXES):
+            sys.exit(0)
+
+        surfaces, always = load_config(root)
+
+        for pat in always:
+            if matches(pat, rel, base):
+                c.block(
+                    root, HOOK, rel, "always-frozen: " + pat,
+                    "BLOCKED: '{}' is a frozen surface ({}). {}".format(
+                        rel, pat, CR_NOTE
+                    ),
+                )
+
+        for s in surfaces:
+            pat = s.get("pattern")
+            if matches(pat, rel, base):
+                why = s.get("why", "declared frozen")
+                via = s.get("change_via", "CR")
+                c.block(
+                    root, HOOK, rel, "frozen: " + pat,
+                    "BLOCKED: '{}' is a frozen surface. WHY: {}. "
+                    "Change via: {}. {}".format(rel, why, via, CR_NOTE),
+                )
+
+        # git-tracked migrations are immutable once shipped.
+        segs = rel.split("/")
+        in_migrations = "migrations" in segs[:-1]
+        in_alembic_versions = False
+        for i in range(len(segs) - 1):
+            if segs[i] == "alembic" and i + 1 < len(segs) and segs[i + 1] == "versions":
+                in_alembic_versions = True
+                break
+        if in_migrations or in_alembic_versions:
+            abs_path = file_path
+            if not os.path.isabs(abs_path):
+                abs_path = os.path.join(root, rel)
+            if c.is_git_tracked(abs_path):
+                c.block(
+                    root, HOOK, rel, "shipped migration",
+                    "BLOCKED: '{}' is a shipped (git-tracked) migration. "
+                    "Migrations are immutable once committed; create a NEW "
+                    "revision instead. {}".format(rel, CR_NOTE),
+                )
+    except SystemExit:
+        raise
+    except Exception:
+        sys.exit(0)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/.claude/hooks/guard_spec.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""PreToolUse (Edit|Write|MultiEdit): enforce spec-before-code.
+
+Writing SOURCE CODE requires an active brief. Non-source files (docs, config,
+data, dotfiles, and anything under company/, .claude/, docs/, .github/) are
+exempt. A hotfix task bypasses the check (logged). Fails open on error.
+"""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import _common as c  # noqa: E402
+
+HOOK = "guard_spec"
+
+NON_SOURCE_EXT = {
+    ".md", ".txt", ".json", ".yaml", ".yml", ".toml", ".cfg", ".ini",
+}
+EXEMPT_DIRS = {"company", ".claude", "docs", ".github"}
+
+NO_BRIEF_MSG = (
+    "BLOCKED: no active brief. Self-serve fix:\n"
+    "1) Write company/briefs/brief-<slug>.md from "
+    "company/templates/BRIEF-TEMPLATE.md covering what you are about to build.\n"
+    "2) Write company/state/active-task.json exactly like this:\n"
+    "   {\"task\": \"<slug>\", \"type\": \"feature\", "
+    "\"brief\": \"company/briefs/brief-<slug>.md\", \"test_scope\": false}\n"
+    "3) Retry the edit.\n"
+    "If you are the CEO handling a production emergency, set type to hotfix "
+    "(logged, not silent)."
+)
+
+
+def is_source(rel, base):
+    if not base:
+        return False
+    if base.startswith("."):
+        return False
+    segs = rel.split("/")
+    if any(s in EXEMPT_DIRS for s in segs[:-1]):
+        return False
+    ext = os.path.splitext(base)[1].lower()
+    if ext in NON_SOURCE_EXT:
+        return False
+    return True
+
+
+def main():
+    payload = c.read_stdin_json()
+    if payload is None:
+        sys.exit(0)
+    if payload.get("tool_name") not in ("Edit", "Write", "MultiEdit"):
+        sys.exit(0)
+
+    root = c.project_root(payload)
+    file_path = (payload.get("tool_input") or {}).get("file_path") or ""
+    if not file_path:
+        sys.exit(0)
+
+    try:
+        rel = c.rel_path(root, file_path)
+        base = os.path.basename(rel) or os.path.basename(file_path)
+        if not is_source(rel, base):
+            sys.exit(0)
+
+        task = c.active_task(root)
+        if isinstance(task, dict) and task.get("type") == "hotfix":
+            c.log_bypass(root, HOOK, rel, "hotfix mode")
+            sys.exit(0)
+
+        brief = task.get("brief") if isinstance(task, dict) else None
+        if not brief:
+            c.block(root, HOOK, rel, "no active brief", NO_BRIEF_MSG)
+
+        brief_path = brief
+        if not os.path.isabs(brief_path):
+            brief_path = os.path.join(root, brief)
+        if not os.path.exists(brief_path):
+            c.block(
+                root, HOOK, rel, "brief file missing: " + str(brief),
+                "BLOCKED: active brief '{}' does not exist. {}".format(
+                    brief, NO_BRIEF_MSG
+                ),
+            )
+    except SystemExit:
+        raise
+    except Exception:
+        sys.exit(0)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/.claude/hooks/guard_tests.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""PreToolUse (Edit|Write|MultiEdit|Bash): anti-reward-hacking on tests.
+
+Tests are the oracle. Editing or deleting them is out of scope unless the
+active brief explicitly opened test scope (active-task.json "test_scope": true).
+
+  - Edit/Write/MultiEdit on a test file: allow only when test_scope is true.
+  - Bash `rm` / `git rm` of a test path: block unless test_scope is true.
+
+Fails open on any internal error.
+"""
+
+import fnmatch
+import os
+import re
+import shlex
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import _common as c  # noqa: E402
+
+HOOK = "guard_tests"
+
+TEST_DIR_SEGMENTS = {"tests", "test", "__tests__", "e2e"}
+OUT_OF_SCOPE = (
+    "BLOCKED: editing tests is out of scope for this brief. Tests are the "
+    "oracle; changing them to pass is reward-hacking. Open test scope in "
+    "company/state/active-task.json (\"test_scope\": true) only if the brief "
+    "calls for it."
+)
+
+
+def is_test_path(path):
+    norm = (path or "").replace("\\", "/")
+    segs = [s for s in norm.split("/") if s]
+    if not segs:
+        return False
+    base = segs[-1]
+    if any(s in TEST_DIR_SEGMENTS for s in segs[:-1]):
+        return True
+    if re.match(r"test_.*\.py$", base):
+        return True
+    if fnmatch.fnmatch(base, "*_test.*"):
+        return True
+    if fnmatch.fnmatch(base, "*.test.*"):
+        return True
+    if fnmatch.fnmatch(base, "*.spec.*"):
+        return True
+    return False
+
+
+def test_scope_open(root):
+    task = c.active_task(root)
+    return isinstance(task, dict) and task.get("test_scope") is True
+
+
+def segments(command):
+    parts = re.split(r"&&|\|\||;|\|", command)
+    return [p.strip() for p in parts if p.strip()]
+
+
+def rm_targets(segment):
+    """Paths a segment tries to remove via rm or git rm, else []."""
+    try:
+        toks = shlex.split(segment)
+    except Exception:
+        toks = segment.split()
+    if not toks:
+        return []
+    if toks[0] == "rm":
+        rest = toks[1:]
+    elif len(toks) >= 2 and toks[0] == "git" and toks[1] == "rm":
+        rest = toks[2:]
+    else:
+        return []
+    return [t for t in rest if not t.startswith("-")]
+
+
+def main():
+    payload = c.read_stdin_json()
+    if payload is None:
+        sys.exit(0)
+    tool = payload.get("tool_name")
+    if tool not in ("Edit", "Write", "MultiEdit", "Bash"):
+        sys.exit(0)
+
+    root = c.project_root(payload)
+    tool_input = payload.get("tool_input") or {}
+
+    try:
+        if tool == "Bash":
+            if test_scope_open(root):
+                sys.exit(0)
+            command = tool_input.get("command") or ""
+            for seg in segments(command):
+                for target in rm_targets(seg):
+                    if is_test_path(target):
+                        c.block(
+                            root, HOOK, target, "rm of test file",
+                            "BLOCKED: removing test file '{}'. {}".format(
+                                target, OUT_OF_SCOPE
+                            ),
+                        )
+            sys.exit(0)
+
+        file_path = tool_input.get("file_path") or ""
+        if not file_path:
+            sys.exit(0)
+        rel = c.rel_path(root, file_path)
+        if not is_test_path(rel):
+            sys.exit(0)
+        if test_scope_open(root):
+            sys.exit(0)
+        c.block(root, HOOK, rel, "test edit out of scope", OUT_OF_SCOPE)
+    except SystemExit:
+        raise
+    except Exception:
+        sys.exit(0)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/.claude/hooks/no_slop.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""PreToolUse (Edit|Write|MultiEdit): block AI-slop tells in inserted text.
+
+Ported from budget-manager's no-ai-slop.py. Scans only the text being written
+(never the old text). Punctuation tells are near-zero false positive; phrase
+tells are deliberately multi-word so they will not trip on identifiers. Files
+under company/state/ (logs) and binary-ish extensions are skipped. Exit 2 on a
+hit, exit 0 otherwise; fails open on malformed input.
+"""
+import json
+import os
+import re
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import _common as c  # noqa: E402
+
+HOOK = "no_slop"
+
+# --- 1. Punctuation tells (char, human-readable name, suggested fix) ---
+PUNCT_TELLS = [
+    ("—", "em dash", "use ' - ', ', ', or split the sentence"),
+    ("–", "en dash", "use a hyphen '-' (or 'to' for ranges)"),
+    ("―", "horizontal bar", "use '-' or rewrite"),
+    ("“", "smart double quote (open)", "use a straight quote \""),
+    ("”", "smart double quote (close)", "use a straight quote \""),
+    ("‘", "smart single quote (open)", "use a straight quote '"),
+    ("’", "smart single quote (close)", "use a straight apostrophe '"),
+    ("…", "ellipsis char", "use three dots '...'"),
+]
+
+# --- 2. Phrase tells (regex, case-insensitive). Multi-word on purpose. ---
+PHRASE_TELLS = [
+    r"\bdelve(s|d|ing)?\b",
+    r"\bit'?s worth noting\b",
+    r"\bit'?s important to note\b",
+    r"\b(a )?testament to\b",
+    r"\bnavigat(e|ing) the (complexit|landscape|world)",
+    r"\bin the (realm|world) of\b",
+    r"\btapestry\b",
+    r"\bat the end of the day\b",
+    r"\bneedless to say\b",
+    r"\bin today'?s (fast-paced|digital|ever-changing)\b",
+    r"\bunlock(ing)? the (power|potential)\b",
+    r"\bsupercharg(e|ed|ing)\b",
+    r"\bseamless(ly)?\b",
+    r"\bbustling\b",
+    r"\bgame.?chang(er|ing)\b",
+    r"\bparadigm shift\b",
+    r"\bnot only\b[^.\n]{0,60}\bbut also\b",
+    r"\bwhen it comes to\b",
+    r"\belevate your\b",
+    r"\bdive (deep|into)\b",
+]
+COMPILED_PHRASES = [re.compile(p, re.IGNORECASE) for p in PHRASE_TELLS]
+
+BINARY_EXT = {
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".pdf", ".zip",
+    ".gz", ".tar", ".woff", ".woff2", ".ttf", ".otf", ".mp4", ".mp3",
+    ".wav", ".bin", ".so", ".dylib", ".o", ".class", ".lockb",
+}
+
+
+def text_under_edit(tool_name, tool_input):
+    if tool_name == "Write":
+        return tool_input.get("content", "") or ""
+    if tool_name == "Edit":
+        return tool_input.get("new_string", "") or ""
+    parts = []
+    for edit in tool_input.get("edits", []) or []:
+        parts.append(edit.get("new_string", "") or "")
+    return "\n".join(parts)
+
+
+def scan(text):
+    hits = []
+    for ch, name, fix in PUNCT_TELLS:
+        if ch in text:
+            n = text.count(ch)
+            hits.append("  - {} x{} -> {}".format(name, n, fix))
+    for pat in COMPILED_PHRASES:
+        m = pat.search(text)
+        if m:
+            hits.append(
+                "  - slop phrase: \"{}\" -> rewrite plainly".format(m.group(0))
+            )
+    return hits
+
+
+def skip_path(file_path):
+    norm = (file_path or "").replace("\\", "/")
+    if "company/state/" in norm:
+        return True
+    ext = os.path.splitext(norm)[1].lower()
+    return ext in BINARY_EXT
+
+
+def main():
+    try:
+        data = json.load(sys.stdin)
+    except Exception:
+        return 0
+    tool_name = data.get("tool_name", "")
+    if tool_name not in ("Write", "Edit", "MultiEdit"):
+        return 0
+    tool_input = data.get("tool_input", {}) or {}
+    file_path = tool_input.get("file_path", "") or ""
+    if skip_path(file_path):
+        return 0
+    text = text_under_edit(tool_name, tool_input)
+    if not text:
+        return 0
+    hits = scan(text)
+    if not hits:
+        return 0
+    try:
+        root = c.project_root(data)
+        c.adherence_log(
+            root, HOOK, "BLOCK", c.rel_path(root, file_path),
+            "slop tells: {}".format(len(hits)),
+        )
+    except Exception:
+        pass
+    print(
+        "Blocked: AI-slop tells found in the text you are writing to "
+        "{}.\n".format(file_path or "<file>") + "\n".join(hits) + "\n"
+        "Rewrite the offending text and retry.",
+        file=sys.stderr,
+    )
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/.claude/hooks/session_start.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""SessionStart hook: print a compact claude-company state digest.
+
+If company/state/RESUME.md or STATUS.md exist, emit a plain-text digest (<= 60
+lines): the first 40 lines of RESUME.md, the first 20 of STATUS.md, and one
+line for the active task. Always exits 0.
+"""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import _common as c  # noqa: E402
+
+MAX_LINES = 60
+
+
+def head_lines(path, n):
+    try:
+        with open(path) as f:
+            out = []
+            for _ in range(n):
+                line = f.readline()
+                if not line:
+                    break
+                out.append(line.rstrip("\n"))
+            return out
+    except Exception:
+        return []
+
+
+def main():
+    payload = c.read_stdin_json() or {}
+    try:
+        root = c.project_root(payload)
+        state = os.path.join(root, "company", "state")
+        resume = os.path.join(state, "RESUME.md")
+        status = os.path.join(state, "STATUS.md")
+        if not (os.path.exists(resume) or os.path.exists(status)):
+            sys.exit(0)
+
+        out = ["claude-company state digest"]
+        if os.path.exists(resume):
+            out.append("-- RESUME.md --")
+            out.extend(head_lines(resume, 40))
+        if os.path.exists(status):
+            out.append("-- STATUS.md --")
+            out.extend(head_lines(status, 20))
+        task = c.active_task(root)
+        if isinstance(task, dict):
+            out.append(
+                "active-task: {} ({}) brief={}".format(
+                    task.get("task"), task.get("type"), task.get("brief")
+                )
+            )
+        print("\n".join(out[:MAX_LINES]))
+    except Exception:
+        pass
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()