coding-os 0.3.2__py3-none-any.whl

scripts/regen_doctor_schema.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""Regenerate src/core/doctor-config.yaml::schema from the live database.py state.
+
+Run this after editing src/core/thinking_os/database.py::MIGRATIONS so doctor's
+EXPECTED_TABLES + expected_version stay in sync with the migration chain.
+
+The test `tests/test_expected_tables_fresh.py` guards this in CI.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+import sys
+import tempfile
+from pathlib import Path
+
+import yaml
+
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+DOCTOR_CONFIG = REPO_ROOT / "src" / "core" / "doctor-config.yaml"
+
+
+def _introspect() -> tuple[int, list[str]]:
+    """Run init_db on an empty DB and return (version, sorted_table_list)."""
+    sys.path.insert(0, str(REPO_ROOT / "src" / "core" / "thinking_os"))
+    from database import MIGRATIONS, init_db  # type: ignore
+
+    version = max(m[0] for m in MIGRATIONS)
+
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as tf:
+        db_path = tf.name
+    try:
+        init_db(db_path)
+        conn = sqlite3.connect(db_path)
+        tables = sorted(
+            row[0]
+            for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")
+            if not row[0].startswith("observations_fts") and not row[0].startswith("sqlite_")
+        )
+        conn.close()
+    finally:
+        Path(db_path).unlink(missing_ok=True)
+
+    return version, tables
+
+
+def main() -> int:
+    version, tables = _introspect()
+    data = yaml.safe_load(DOCTOR_CONFIG.read_text(encoding="utf-8"))
+    schema = data.setdefault("schema", {})
+    schema["expected_version"] = version
+    schema["expected_tables"] = tables
+    DOCTOR_CONFIG.write_text(
+        yaml.dump(data, sort_keys=False, default_flow_style=False),
+        encoding="utf-8",
+    )
+    print(f"[doctor-schema] version={version} tables={len(tables)} → {DOCTOR_CONFIG}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/regen_rules.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Regenerate core/rules/dimension-registry.md and core/rules/skill-enforcement.md.
+
+Both files are generated from the live stack registry:
+
+    core/rules/dimension-registry.md   ← aggregated world.dimensions
+    core/rules/skill-enforcement.md    ← aggregated world.skill_enforcement
+
+Run after editing any `templates/<stack>/stack.yaml` that changes
+`dimensions:` or `skill_enforcement:` lists. `tests/test_rules_fresh.py`
+guards freshness in CI.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+CORE_RULES = REPO_ROOT / "src" / "core" / "rules"
+DIMENSION_REGISTRY_PATH = CORE_RULES / "dimension-registry.md"
+SKILL_ENFORCEMENT_PATH = CORE_RULES / "skill-enforcement.md"
+
+
+def _build_world():
+    """Build an AggregatedWorld containing every installed stack."""
+    sys.path.insert(0, str(REPO_ROOT))
+    from cli._data_types import AdapterProfile
+    from cli.adapter_registry import load_adapter_registry
+    from cli.aggregator import aggregate, today_iso
+    from cli.stack_registry import load_base_profile, load_stack_registry
+
+    base = load_base_profile(REPO_ROOT / "src" / "templates" / "_base")
+    stacks_reg = load_stack_registry(REPO_ROOT / "src" / "templates")
+    adapters = load_adapter_registry(REPO_ROOT / "src" / "adapters")
+
+    # Use claude if available, otherwise first adapter, otherwise a stub.
+    if "claude" in adapters:
+        adapter = adapters["claude"]
+    elif adapters:
+        adapter = next(iter(adapters.values()))
+    else:
+        adapter = AdapterProfile(
+            id="stub",
+            label="stub",
+            settings_file=None,
+            hooks_dir=None,
+            rules_dir=None,
+            skills_dir=None,
+            sourced_hooks=(),
+            supports_rules=False,
+            supports_settings_json=False,
+            install_script=Path("."),
+            default_settings={},
+            source_dir=Path("."),
+        )
+
+    all_stacks = [stacks_reg[sid] for sid in sorted(stacks_reg.keys())]
+    return aggregate(
+        base,
+        all_stacks,
+        adapter,
+        "coding-os",
+        today=today_iso(),
+    )
+
+
+def main() -> int:
+    from cli.renderer import (
+        render_dimension_registry,
+        render_skill_enforcement,
+    )
+
+    world = _build_world()
+
+    CORE_RULES.mkdir(parents=True, exist_ok=True)
+    dim_content = render_dimension_registry(world)
+    enf_content = render_skill_enforcement(world)
+
+    DIMENSION_REGISTRY_PATH.write_text(dim_content, encoding="utf-8")
+    SKILL_ENFORCEMENT_PATH.write_text(enf_content, encoding="utf-8")
+
+    print(f"[regen-rules] wrote {DIMENSION_REGISTRY_PATH.relative_to(REPO_ROOT)}")
+    print(f"[regen-rules] wrote {SKILL_ENFORCEMENT_PATH.relative_to(REPO_ROOT)}")
+    print(
+        f"[regen-rules] {len(world.dimensions)} dimensions, "
+        f"{len(world.skill_enforcement)} skill-enforcement rows, "
+        f"from {len(world.stack_ids)} stacks"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/rename_formulas_to_semantic.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""Rename F1–F11 formula codes to semantic role names across the repo.
+
+USAGE:        Already run on 2026-04 — kept for historical reference.
+              Re-running is safe (idempotent regex; renames skip if
+              destination exists).
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+
+# Mapping stored via hex codes so the migration patterns themselves
+# don't match this file. _D() decodes a hex-encoded ASCII literal.
+def _D(hex_str: str) -> str:
+    return bytes.fromhex(hex_str).decode("ascii")
+
+
+# Role codes: hex(F1) = "4631", hex(F2) = "4632", … hex(F11) = "463131"
+_CODE_HEX = [
+    "4631",
+    "4632",
+    "4633",
+    "4634",
+    "4635",
+    "4636",
+    "4637",
+    "4638",
+    "4639",
+    "463130",
+    "463131",
+]
+_NAMES = [
+    "researcher",
+    "analyst",
+    "architect",
+    "documenter",
+    "implementer",
+    "reviewer",
+    "debugger",
+    "security_auditor",
+    "deployer",
+    "observer",
+    "refactorer",
+]
+_PYDANTIC_NAMES = [
+    "Researcher",
+    "Analyst",
+    "Architect",
+    "Documenter",
+    "Implementer",
+    "Reviewer",
+    "Debugger",
+    "SecurityAuditor",
+    "Deployer",
+    "Observer",
+    "Refactorer",
+]
+ROLE_MAP: dict[str, str] = dict(zip([_D(h) for h in _CODE_HEX], _NAMES))
+PYDANTIC_MAP: dict[str, str] = dict(zip([_D(h) for h in _CODE_HEX], _PYDANTIC_NAMES))
+
+# Compound field names like  hex(F2_decompose) used in Pydantic schemas.
+_VERBS = [
+    "research",
+    "decompose",
+    "architect",
+    "document",
+    "implement",
+    "test_review",
+    "debug",
+    "security",
+    "deploy",
+    "monitor",
+    "refactor",
+]
+COMPOUND_MAP: dict[str, str] = {
+    f"{_D(h)}_{verb}": name for h, verb, name in zip(_CODE_HEX, _VERBS, _NAMES)
+}
+
+FILE_RENAMES: dict[str, str] = {}
+PATH_FRAGMENT_RENAMES: dict[str, str] = {}
+for h, verb, name in zip(_CODE_HEX, _VERBS, _NAMES):
+    code = _D(h)
+    # roles/F<n>_<name>.yaml → <name>.yaml
+    FILE_RENAMES[f"{code}_{name}.yaml"] = f"{name}.yaml"
+    # agents/F<n>_<verb>.md → <name>.md
+    FILE_RENAMES[f"{code}_{verb}.md"] = f"{name}.md"
+    PATH_FRAGMENT_RENAMES[f"agents/{code}_{verb}"] = f"agents/{name}"
+    PATH_FRAGMENT_RENAMES[f"roles/{code}_{name}"] = f"roles/{name}"
+
+
+EXCLUDE_DIR_FRAGMENTS = (
+    "/.venv/",
+    "/.build/",
+    "/.git/",
+    "/__pycache__/",
+    "/tests/golden/",
+    "/.coding-os/",
+    "/node_modules/",
+    "/.claude/",
+    "/.codex/",
+    "/coding_os.egg-info/",
+    "/dist/",
+)
+
+PRESERVE_F_NUMBERING: tuple[str, ...] = (
+    "docs/code-os-core-docs/thinkingos-formulas/formulas-en.md",
+    "docs/code-os-core-docs/thinkingos-formulas/formulas-v2.md",
+    # Skip self — script's mapping table can't be rewritten.
+    "src/scripts/rename_formulas_to_semantic.py",
+)
+
+INCLUDE_SUFFIXES = (".py", ".md", ".yaml", ".yml", ".json", ".sh", ".toml")
+
+
+def is_excluded(path: Path) -> bool:
+    s = "/" + str(path).lstrip("/") + "/"
+    return any(frag in s for frag in EXCLUDE_DIR_FRAGMENTS)
+
+
+def is_preserved(path: Path, root: Path) -> bool:
+    rel = str(path.relative_to(root))
+    return any(rel == p or rel.endswith("/" + p) for p in PRESERVE_F_NUMBERING)
+
+
+def build_replacers() -> list[tuple[re.Pattern, str, str]]:
+    pats: list[tuple[re.Pattern, str, str]] = []
+
+    # 1. Pydantic class names (longest first so 4631_30 wins over 4631).
+    for code in sorted(PYDANTIC_MAP, key=lambda c: -len(c)):
+        new = PYDANTIC_MAP[code]
+        pats.append((re.compile(rf"\b{code}Output\b"), f"{new}Output", f"{code}Output→{new}Output"))
+        pats.append((re.compile(rf"\b{code}Input\b"), f"{new}Input", f"{code}Input→{new}Input"))
+
+    # 2. Path fragments
+    for old, new in PATH_FRAGMENT_RENAMES.items():
+        pats.append((re.compile(re.escape(old)), new, f"{old}→{new}"))
+
+    # 3. Compound field names (uppercase + lowercase)
+    for old in sorted(COMPOUND_MAP, key=lambda c: -len(c)):
+        new = COMPOUND_MAP[old]
+        pats.append((re.compile(rf"\b{old}\b"), new, f"{old}→{new}"))
+        lower = old.lower()
+        if lower != old:
+            pats.append((re.compile(rf"\b{lower}\b"), new, f"{lower}→{new}"))
+
+    # 4. Quoted F-codes
+    for code in sorted(ROLE_MAP, key=lambda c: -len(c)):
+        new = ROLE_MAP[code]
+        pats.append((re.compile(rf'"({code})"'), f'"{new}"', f'"{code}"→"{new}"'))
+        pats.append((re.compile(rf"'({code})'"), f"'{new}'", f"'{code}'→'{new}'"))
+
+    # 5. YAML id field
+    for code in sorted(ROLE_MAP, key=lambda c: -len(c)):
+        new = ROLE_MAP[code]
+        pats.append(
+            (re.compile(rf"^(\s*id:\s*){code}\b", re.MULTILINE), rf"\1{new}", f"id:{code}→id:{new}")
+        )
+        pats.append(
+            (
+                re.compile(rf"^(\s*formula_ref:\s*){code}\b", re.MULTILINE),
+                rf"\1{new}",
+                f"formula_ref:{code}→formula_ref:{new}",
+            )
+        )
+
+    return pats
+
+
+def rewrite_file(path: Path, replacers, dry_run: bool):
+    try:
+        original = path.read_text(encoding="utf-8")
+    except (UnicodeDecodeError, PermissionError):
+        return False, []
+    text = original
+    hits: list[str] = []
+    for pat, repl, label in replacers:
+        new_text, n = pat.subn(repl, text)
+        if n:
+            hits.append(f"  {n}× {label}")
+        text = new_text
+    if text != original:
+        if not dry_run:
+            path.write_text(text, encoding="utf-8")
+        return True, hits
+    return False, hits
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parent.parent.parent)
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+
+    root = args.root.resolve()
+    print(f"Repo root: {root}")
+    print(f"Dry run:   {args.dry_run}")
+
+    replacers = build_replacers()
+
+    rewritten = 0
+    for path in root.rglob("*"):
+        if not path.is_file():
+            continue
+        if is_excluded(path):
+            continue
+        if path.suffix not in INCLUDE_SUFFIXES:
+            continue
+        if is_preserved(path, root):
+            continue
+        changed, hits = rewrite_file(path, replacers, args.dry_run)
+        if changed:
+            rewritten += 1
+            rel = path.relative_to(root)
+            print(f"\n[rewrite] {rel}")
+            for h in hits:
+                print(h)
+
+    renamed = 0
+    for old_basename, new_basename in FILE_RENAMES.items():
+        for old_path in root.rglob(old_basename):
+            if is_excluded(old_path):
+                continue
+            new_path = old_path.parent / new_basename
+            if new_path.exists():
+                continue
+            print(f"\n[rename] {old_path.relative_to(root)} → {new_basename}")
+            if not args.dry_run:
+                old_path.rename(new_path)
+            renamed += 1
+
+    print(f"\nDone. {rewritten} file(s) rewritten, {renamed} file(s) renamed.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/smoke_db_connections.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+"""End-to-end smoke for DB connection unification.
+
+Confirms every component (thinking_os, graph_os, board_os, web Hub,
+hook helpers) opens the SAME canonical SQLite file and that
+`resolve_db_path()` is the single source of truth.
+
+For each connection site, the script:
+1. Calls the resolver / opener.
+2. Reads back the canonical file path.
+3. Asserts it matches the expected `<project>/.coding-os/coding-os.db`.
+4. Performs a real read against the live DB to confirm it's open.
+
+Run: uv run python scripts/smoke_db_connections.py
+Exit: 0 if all PASS; 1 if any FAIL.
+"""
+
+from __future__ import annotations
+
+import os
+import sqlite3
+import sys
+from collections.abc import Callable
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+sys.path.insert(0, str(REPO_ROOT / "src" / "core"))
+sys.path.insert(0, str(REPO_ROOT))
+
+EXPECTED = Path(
+    os.environ.get("COS_DB_PATH") or REPO_ROOT / ".coding-os" / "coding-os.db"
+).resolve()
+
+
+def _check(name: str, fn: Callable[[], Path | str | None]) -> tuple[str, bool, str]:
+    try:
+        path = fn()
+    except Exception as exc:
+        return name, False, f"raised {type(exc).__name__}: {exc}"
+    if path is None:
+        return name, False, "returned None"
+    actual = Path(path).resolve()
+    if actual != EXPECTED:
+        return name, False, f"path mismatch: {actual} != {EXPECTED}"
+    return name, True, str(actual)
+
+
+def _real_query(name: str, db_path: str) -> tuple[str, bool, str]:
+    """Open the path with sqlite3 and run a tiny read to confirm it's live."""
+    try:
+        conn = sqlite3.connect(db_path)
+        try:
+            row = conn.execute("SELECT COUNT(*) FROM graph_nodes").fetchone()
+            nodes = row[0] if row else 0
+        finally:
+            conn.close()
+    except Exception as exc:
+        return name, False, f"sqlite open/read failed: {exc}"
+    return name, True, f"graph_nodes={nodes}"
+
+
+def main() -> int:
+    sites: list[tuple[str, Callable[[], Path | str | None]]] = []
+
+    # 1. canonical helper
+    def site_resolve():
+        from thinking_os.database import resolve_db_path
+
+        return resolve_db_path(REPO_ROOT)
+
+    sites.append(("thinking_os.database.resolve_db_path(REPO_ROOT)", site_resolve))
+
+    # 2. DEFAULT_DB_PATH constant (cwd-based default)
+    def site_default():
+        from thinking_os.database import DEFAULT_DB_PATH
+
+        return DEFAULT_DB_PATH
+
+    sites.append(("thinking_os.database.DEFAULT_DB_PATH", site_default))
+
+    # 3. Web Hub current_db_path
+    def site_web():
+        from web._project_context import current_db_path
+
+        return current_db_path()
+
+    sites.append(("web._project_context.current_db_path()", site_web))
+
+    # 4. graph_os SqliteBackend default path resolution
+    def site_graph_backend():
+        from graph_os.backends.sqlite_backend import SqliteBackend
+
+        # Construct a backend without conn to trigger resolve_db_path
+        # then close.  Use a temp dir env override so we don't recreate
+        # the production DB if it doesn't exist on this machine.
+        be = SqliteBackend()
+        try:
+            return be._conn.execute(
+                "SELECT file FROM pragma_database_list WHERE name='main'"
+            ).fetchone()[0]
+        finally:
+            be.close()
+
+    sites.append(("graph_os.SqliteBackend default", site_graph_backend))
+
+    # 5. cognition route resolver (Hub)
+    def site_cognition():
+        os.environ["COS_PROJECT_ROOT"] = str(REPO_ROOT)
+        from web.routes.cognition import _db_path
+
+        return _db_path()
+
+    sites.append(("web.routes.cognition._db_path()", site_cognition))
+
+    # 6. hook helper resolution (work_log_append)
+    def site_hook_work_log():
+        from thinking_os.database import resolve_db_path
+
+        os.environ["COS_PROJECT_ROOT"] = str(REPO_ROOT)
+        # The hook itself imports resolve_db_path lazily — exercise it directly.
+        return resolve_db_path(REPO_ROOT)
+
+    sites.append(("hook _helpers/work_log_append (via resolve_db_path)", site_hook_work_log))
+
+    # 7. board_os transition_gates fallback
+    def site_board_gates():
+        from thinking_os.database import resolve_db_path
+
+        return resolve_db_path()
+
+    sites.append(("board_os.transition_gates_cli (via resolve_db_path)", site_board_gates))
+
+    print(f"\nExpected canonical: {EXPECTED}")
+    print(f"{'=' * 78}")
+    pass_n = 0
+    fail_n = 0
+    paths_seen: set[str] = set()
+
+    for name, fn in sites:
+        site_name, ok, detail = _check(name, fn)
+        glyph = "✓" if ok else "✗"
+        print(f"  {glyph} {site_name}")
+        print(f"      {detail}")
+        if ok:
+            pass_n += 1
+            paths_seen.add(detail)
+        else:
+            fail_n += 1
+
+    # ── Live read verification ─────────────────────────────────────
+    print(f"\n{'=' * 78}")
+    print("Live read smoke (sqlite3.connect → SELECT COUNT(*) FROM graph_nodes)")
+    print(f"{'=' * 78}")
+    if EXPECTED.exists():
+        live_name, live_ok, live_detail = _real_query("canonical", str(EXPECTED))
+        glyph = "✓" if live_ok else "✗"
+        print(f"  {glyph} {live_name}: {live_detail}")
+        if not live_ok:
+            fail_n += 1
+        else:
+            pass_n += 1
+    else:
+        print(f"  ⚠ canonical DB does not exist at {EXPECTED}")
+        print(
+            "     run `cos init` or `python -c 'from thinking_os.database import init_db; init_db()'` first"
+        )
+
+    # ── Final assertion ────────────────────────────────────────────
+    print(f"\n{'=' * 78}")
+    print(f"Distinct paths seen across {len(sites)} sites: {len(paths_seen)}")
+    if len(paths_seen) == 1:
+        print("  → SHARED ✓ (every site resolves to the same canonical file)")
+    else:
+        print("  → DIVERGED ✗")
+        for p in sorted(paths_seen):
+            print(f"     - {p}")
+
+    print(f"\nRESULT: {pass_n} pass · {fail_n} fail")
+    return 0 if fail_n == 0 and len(paths_seen) <= 1 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/smoke_doc_header.py

@@ -0,0 +1,72 @@
+"""Smoke test for cos_doc_header + cos_doc_headers_by (TASK-155)."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+# Make tools/ importable the same way server.py does it.
+THINKING_OS = Path(__file__).resolve().parent.parent.parent / "src" / "core" / "thinking_os"
+sys.path.insert(0, str(THINKING_OS))
+
+from tools.docs import list_doc_headers, parse_doc_header
+
+ROOT = Path(__file__).resolve().parent.parent.parent
+GOVERNANCE = ROOT / "docs" / "governance"
+
+
+def _check(condition: bool, message: str) -> None:
+    print(("OK  : " if condition else "FAIL: ") + message)
+    if not condition:
+        sys.exit(1)
+
+
+def main() -> None:
+    # Single-doc parse.
+    target = GOVERNANCE / "critical-rules.md"
+    header = parse_doc_header(target)
+    _check(header is not None, f"parse_doc_header returns dict for {target.name}")
+    fm = header["frontmatter"]
+    ob = header["opening_block"]
+    _check(fm.get("domain") == "DOCS", f"frontmatter domain == DOCS (got {fm.get('domain')!r})")
+    _check(fm.get("layer") == "policy", f"frontmatter layer == policy (got {fm.get('layer')!r})")
+    _check(bool(ob.get("purpose")), "opening_block.purpose populated")
+    _check(bool(ob.get("read_when")), "opening_block.read_when populated")
+    _check(bool(ob.get("read_next")), "opening_block.read_next populated")
+    _check(
+        header["header_token_estimate"] < 300,
+        f"header_token_estimate < 300 (got {header['header_token_estimate']})",
+    )
+
+    # Bulk scan with filter.
+    rows = list_doc_headers(GOVERNANCE, domain="DOCS", limit=20)
+    _check(len(rows) >= 3, f"list_doc_headers found ≥3 DOCS rows (got {len(rows)})")
+    titles = [r["title"] for r in rows]
+    _check(
+        "Critical Rules — Full Text" in titles, f"Critical Rules surfaced (titles={titles[:3]}…)"
+    )
+
+    # Filter by layer.
+    policies = list_doc_headers(GOVERNANCE, domain="DOCS", layer="policy", limit=20)
+    _check(
+        len(policies) >= 1, f"list_doc_headers(domain=DOCS, layer=policy) ≥1 (got {len(policies)})"
+    )
+
+    # Negative — non-existent layer.
+    none = list_doc_headers(GOVERNANCE, domain="DOCS", layer="not-a-layer")
+    _check(none == [], "filter on bogus layer returns empty list")
+
+    # Compact JSON dump for visual inspection.
+    print("\nSample header:")
+    print(
+        json.dumps(
+            {k: header[k] for k in ("title", "frontmatter", "opening_block")},
+            indent=2,
+            ensure_ascii=False,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()