codexkit 1.0.0

package/.codex/scripts/build_memory_index.sh

@@ -0,0 +1,167 @@
+#!/bin/bash
+set -euo pipefail
+
+# Script: build_memory_index
+# Builds derived JSONL and SQLite/FTS indexes from repo-visible memory/context markdown files.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+INDEX_DIR="$SCRIPT_DIR/memory/.index"
+INDEX_FILE="$INDEX_DIR/memory-index.jsonl"
+DB_FILE="$INDEX_DIR/memory-index.db"
+
+mkdir -p "$INDEX_DIR"
+
+python3 - "$SCRIPT_DIR" "$INDEX_FILE" "$DB_FILE" <<'PY'
+import json
+import re
+import sqlite3
+import sys
+from pathlib import Path
+
+root = Path(sys.argv[1])
+index_file = Path(sys.argv[2])
+db_file = Path(sys.argv[3])
+targets = [
+    root / "context",
+    root / "memory" / "project",
+    root / "memory" / "research",
+]
+heading_re = re.compile(r"^(#{1,6})\s+(.*)$")
+
+
+def classify_path(rel_path: str) -> str:
+    if rel_path == "context/decision-log.md":
+        return "decision-log"
+    if rel_path == "context/session-context.md":
+        return "session-context"
+    if rel_path == "context/worklog.md":
+        return "worklog"
+    if rel_path == "memory/project/state.md":
+        return "project-state"
+    if rel_path.startswith("memory/project/"):
+        return "project-memory"
+    if rel_path.startswith("memory/research/"):
+        return "research"
+    if rel_path.startswith("context/"):
+        return "context"
+    return "other"
+
+
+def iter_sections(path: Path):
+    text = path.read_text(encoding="utf-8", errors="replace")
+    lines = text.splitlines()
+    current_heading = "Document"
+    current_level = 1
+    buffer = []
+
+    def flush():
+        body = "\n".join(buffer).strip()
+        if body:
+            yield {
+                "heading": current_heading,
+                "level": current_level,
+                "body": body,
+            }
+
+    for line in lines:
+        match = heading_re.match(line)
+        if match:
+            yield from flush()
+            current_level = len(match.group(1))
+            current_heading = match.group(2).strip()
+            buffer = []
+            continue
+        buffer.append(line)
+
+    yield from flush()
+
+
+records = []
+for target in targets:
+    if not target.exists():
+        continue
+    for path in sorted(target.rglob("*.md")):
+        if not path.is_file():
+            continue
+        rel_path = path.relative_to(root).as_posix()
+        mtime = int(path.stat().st_mtime)
+        for section in iter_sections(path):
+            snippet = re.sub(r"\s+", " ", section["body"]).strip()
+            if not snippet:
+                continue
+            source_type = classify_path(rel_path)
+            token_count = len(re.findall(r"[A-Za-z0-9_./-]+", snippet))
+            records.append(
+                {
+                    "path": rel_path,
+                    "heading": section["heading"],
+                    "level": section["level"],
+                    "source_type": source_type,
+                    "snippet": snippet[:400],
+                    "token_count": token_count,
+                    "mtime": mtime,
+                }
+            )
+
+with index_file.open("w", encoding="utf-8") as fh:
+    for record in records:
+        fh.write(json.dumps(record, ensure_ascii=True) + "\n")
+
+if db_file.exists():
+    db_file.unlink()
+
+conn = sqlite3.connect(db_file)
+try:
+    conn.execute("PRAGMA journal_mode = OFF")
+    conn.execute("PRAGMA synchronous = OFF")
+    conn.execute("PRAGMA temp_store = MEMORY")
+    conn.execute(
+        """
+        CREATE TABLE sections (
+            id INTEGER PRIMARY KEY,
+            path TEXT NOT NULL,
+            heading TEXT NOT NULL,
+            level INTEGER NOT NULL,
+            source_type TEXT NOT NULL,
+            snippet TEXT NOT NULL,
+            token_count INTEGER NOT NULL,
+            mtime INTEGER NOT NULL
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE VIRTUAL TABLE sections_fts USING fts5(
+            path,
+            heading,
+            source_type,
+            snippet,
+            content='sections',
+            content_rowid='id',
+            tokenize='unicode61'
+        )
+        """
+    )
+    conn.executemany(
+        "INSERT INTO sections(path, heading, level, source_type, snippet, token_count, mtime) VALUES (?, ?, ?, ?, ?, ?, ?)",
+        [
+            (
+                r["path"],
+                r["heading"],
+                r["level"],
+                r["source_type"],
+                r["snippet"],
+                r["token_count"],
+                r["mtime"],
+            )
+            for r in records
+        ],
+    )
+    conn.execute("INSERT INTO sections_fts(sections_fts) VALUES ('rebuild')")
+    conn.commit()
+finally:
+    conn.close()
+
+print(f"Indexed {len(records)} sections -> {index_file}")
+print(f"Built SQLite/FTS index -> {db_file}")
+PY

package/.codex/scripts/build_prior_related_work.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+set -euo pipefail
+# Script: build_prior_related_work
+# Turn ranked bead-context search results into a reusable PRD section.
+
+PROJECT_ROOT="${CODEXKIT_PROJECT_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)}"
+QUERY=""
+LIMIT=3
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --limit)
+      shift
+      LIMIT="${1:-3}"
+      ;;
+    --limit=*)
+      LIMIT="${1#--limit=}"
+      ;;
+    *)
+      if [[ -z "$QUERY" ]]; then
+        QUERY="$1"
+      else
+        QUERY="$QUERY $1"
+      fi
+      ;;
+  esac
+  shift || true
+done
+
+if [[ -z "$QUERY" ]]; then
+  echo "Usage: $0 <query> [--limit <n>]" >&2
+  exit 1
+fi
+
+SEARCH_OUTPUT="$("$PROJECT_ROOT/.codex/scripts/search_bead_context.sh" "$QUERY" --limit "$LIMIT")"
+
+SEARCH_OUTPUT="$SEARCH_OUTPUT" python3 - "$PROJECT_ROOT" "$QUERY" <<'PY'
+import re
+import os
+import sys
+from pathlib import Path
+
+project_root = Path(sys.argv[1])
+query = sys.argv[2]
+search_output = os.environ.get("SEARCH_OUTPUT", "")
+lines = search_output.splitlines()
+
+
+def read_text(path: Path) -> str:
+    if not path.exists() or not path.is_file():
+        return ""
+    return path.read_text(encoding="utf-8", errors="replace")
+
+
+def extract_section(text: str, heading: str) -> str:
+    pattern = re.compile(
+        rf"^##+\s+{re.escape(heading)}\s*$\n(.*?)(?=^##+\s+|\Z)",
+        re.MULTILINE | re.DOTALL,
+    )
+    match = pattern.search(text)
+    return match.group(1).strip() if match else ""
+
+
+hits = []
+for line in lines:
+    match = re.match(r"^\d+\.\s+\[score=\d+\]\s+(.+)$", line)
+    if not match:
+        continue
+    path = match.group(1).strip()
+    if not path.startswith(".codex/memory/research/beads/"):
+        continue
+    summary_path = project_root / path
+    summary_text = read_text(summary_path)
+    if not summary_text:
+        continue
+    bead_section = extract_section(summary_text, "Bead")
+    outcome_section = extract_section(summary_text, "Outcome")
+    decisions_section = extract_section(summary_text, "Key Decisions")
+    followups_section = extract_section(summary_text, "Follow-ups")
+
+    title = summary_text.splitlines()[0].removeprefix("# ").strip() if summary_text.splitlines() else summary_path.stem
+    bead_id = summary_path.stem
+    status = "unknown"
+    for raw_line in bead_section.splitlines():
+        line = raw_line.strip()
+        if line.startswith("- Status:"):
+            status = line.split(":", 1)[1].strip()
+            break
+
+    def first_bullet(section: str, fallback: str) -> str:
+        for raw_line in section.splitlines():
+            line = raw_line.strip()
+            if line.startswith("- "):
+                return line[2:].strip()
+        compact = " ".join(line.strip() for line in section.splitlines() if line.strip())
+        return compact or fallback
+
+    outcome = first_bullet(outcome_section, "No reusable outcome captured")
+    decision = first_bullet(decisions_section, "No durable decision captured")
+    followup = first_bullet(followups_section, "No follow-up recorded")
+    hits.append(
+        {
+            "bead_id": bead_id,
+            "title": title,
+            "status": status,
+            "path": path,
+            "outcome": outcome,
+            "decision": decision,
+            "followup": followup,
+        }
+    )
+
+print("## Prior Related Work")
+print()
+print(f"- Query: {query}")
+if not hits:
+    print("- No relevant prior bead summaries were found.")
+    raise SystemExit(0)
+
+for hit in hits:
+    print(f"- `{hit['bead_id']}` ({hit['status']}) — {hit['title']}")
+    print(f"  Reuse: {hit['outcome']}")
+    print(f"  Carry forward: {hit['decision']}")
+    if hit["followup"] != "No follow-up recorded":
+        print(f"  Watch for: {hit['followup']}")
+    print(f"  Source: `{hit['path']}`")
+PY

package/.codex/scripts/build_startup_brief.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+set -euo pipefail
+# Script: build_startup_brief
+# Generates session startup context and prints to stdout.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+echo "━━━ Startup Brief ━━━"
+
+# Current git branch and status
+BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")
+echo "📌 Branch: $BRANCH"
+
+STATUS=$(git status --porcelain 2>/dev/null)
+if [[ -n "$STATUS" ]]; then
+  MODIFIED=$(echo "$STATUS" | wc -l | tr -d ' ')
+  echo "⚠️  $MODIFIED file(s) with uncommitted changes"
+else
+  echo "✅ Working tree clean"
+fi
+
+# Last 5 commits
+echo ""
+echo "📝 Last 5 commits:"
+git log --oneline -5 2>/dev/null || echo "  (no commits yet)"
+
+# Current priorities
+PRIORITIES_FILE="$SCRIPT_DIR/context/current-priorities.md"
+if [[ -f "$PRIORITIES_FILE" ]]; then
+  echo ""
+  echo "🎯 Current Priorities:"
+  head -20 "$PRIORITIES_FILE"
+fi
+
+# Durable project state
+STATE_FILE="$SCRIPT_DIR/memory/project/state.md"
+if [[ -f "$STATE_FILE" ]]; then
+  echo ""
+  echo "🧠 Durable State:"
+  head -20 "$STATE_FILE"
+fi
+
+# Blockers from worklog
+WORKLOG="$SCRIPT_DIR/context/worklog.md"
+if [[ -f "$WORKLOG" ]]; then
+  BLOCKERS=$(grep -i "block" "$WORKLOG" | tail -5)
+  if [[ -n "$BLOCKERS" ]]; then
+    echo ""
+    echo "🚧 Recent blockers from worklog:"
+    echo "$BLOCKERS"
+  fi
+fi

package/.codex/scripts/close_bead.sh

@@ -0,0 +1,103 @@
+#!/bin/bash
+set -euo pipefail
+# Script: close_bead
+# Sync bead artifacts into durable context, then close and flush bead state.
+
+PROJECT_ROOT="${CODEXKIT_PROJECT_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)}"
+BEAD_ID="${1:-}"
+REASON=""
+SKIP_FLUSH=false
+
+if [[ -z "$BEAD_ID" ]]; then
+  echo "Usage: $0 <bead-id> [--reason <text>] [--skip-flush]" >&2
+  exit 1
+fi
+shift || true
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --reason)
+      shift
+      REASON="${1:-}"
+      ;;
+    --reason=*)
+      REASON="${1#--reason=}"
+      ;;
+    --skip-flush)
+      SKIP_FLUSH=true
+      ;;
+    *)
+      echo "Unknown option: $1" >&2
+      echo "Usage: $0 <bead-id> [--reason <text>] [--skip-flush]" >&2
+      exit 1
+      ;;
+  esac
+  shift || true
+done
+
+if [[ -z "$REASON" ]]; then
+  REASON="Completed with synced bead context"
+fi
+
+SYNC_SCRIPT="$PROJECT_ROOT/.codex/scripts/sync_bead_context.sh"
+if [[ ! -x "$SYNC_SCRIPT" ]]; then
+  echo "Missing sync script: $SYNC_SCRIPT" >&2
+  exit 1
+fi
+
+if ! command -v br >/dev/null 2>&1; then
+  echo "Missing dependency: br" >&2
+  exit 1
+fi
+
+get_bead_status() {
+  local bead_id="$1"
+  local status_json
+
+  if ! status_json="$(br show --json "$bead_id" 2>/dev/null)"; then
+    echo "unknown"
+    return 0
+  fi
+
+  python3 - "$status_json" <<'PY'
+import json
+import sys
+
+raw = sys.argv[1]
+
+try:
+    data = json.loads(raw)
+except json.JSONDecodeError:
+    print("unknown")
+    raise SystemExit(0)
+
+status = "unknown"
+if isinstance(data, dict):
+    if isinstance(data.get("status"), str):
+        status = data["status"]
+    elif isinstance(data.get("issue"), dict) and isinstance(data["issue"].get("status"), str):
+        status = data["issue"]["status"]
+    elif isinstance(data.get("issues"), list) and data["issues"]:
+        first = data["issues"][0]
+        if isinstance(first, dict) and isinstance(first.get("status"), str):
+            status = first["status"]
+elif isinstance(data, list) and data:
+    first = data[0]
+    if isinstance(first, dict) and isinstance(first.get("status"), str):
+        status = first["status"]
+
+print(status)
+PY
+}
+
+(
+  cd "$PROJECT_ROOT"
+  bead_status="$(get_bead_status "$BEAD_ID")"
+  if [[ "$bead_status" != "closed" ]]; then
+    br close "$BEAD_ID" --reason "$REASON"
+  fi
+  "$SYNC_SCRIPT" "$BEAD_ID"
+  if ! $SKIP_FLUSH; then
+    br sync --flush-only
+  fi
+)

package/.codex/scripts/detect_changed_files.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+set -euo pipefail
+# Script: detect_changed_files
+# Lists modified files (unstaged, staged, and all) for review.
+
+echo "━━━ Changed Files ━━━"
+
+# Unstaged changes
+UNSTAGED=$(git diff --name-only 2>/dev/null)
+if [[ -n "$UNSTAGED" ]]; then
+  echo ""
+  echo "📄 Unstaged changes:"
+  echo "$UNSTAGED" | while read -r f; do echo "  M  $f"; done
+fi
+
+# Staged changes
+STAGED=$(git diff --cached --name-only 2>/dev/null)
+if [[ -n "$STAGED" ]]; then
+  echo ""
+  echo "📦 Staged changes:"
+  echo "$STAGED" | while read -r f; do echo "  S  $f"; done
+fi
+
+# All changes vs HEAD
+ALL=$(git diff HEAD --name-only 2>/dev/null)
+if [[ -z "$UNSTAGED" && -z "$STAGED" && -z "$ALL" ]]; then
+  echo "  ✅ No changes detected"
+fi
+
+# Untracked files
+UNTRACKED=$(git ls-files --others --exclude-standard 2>/dev/null)
+if [[ -n "$UNTRACKED" ]]; then
+  echo ""
+  echo "❓ Untracked files:"
+  echo "$UNTRACKED" | while read -r f; do echo "  ?  $f"; done
+fi
+
+echo "━━━━━━━━━━━━━━━━━━━━━"

package/.codex/scripts/ensure_beads.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+set -euo pipefail
+
+if ! command -v br >/dev/null 2>&1; then
+  echo "br CLI not found. Install beads_rust before using bead workflows." >&2
+  exit 1
+fi
+
+if [ -d ".beads" ]; then
+  exit 0
+fi
+
+br init >/dev/null
+echo "Initialized .beads via br init"