vibe-forge 0.4.0 → 0.8.2

package/src/lib/daemon/state.sh

@@ -0,0 +1,163 @@
+#!/usr/bin/env bash
+#
+# src/lib/daemon/state.sh
+#
+# Daemon state management - forge-state.yaml updates, attention tracking,
+# adaptive polling
+#
+# Dependencies: database.sh, constants.sh
+# Requires: sync.sh (for build_worker_status)
+# Globals required: FORGE_ROOT, STATE_FILE, AGENT_STATUS_DIR,
+#                   TASKS_PENDING, TASKS_IN_PROGRESS, TASKS_COMPLETED,
+#                   TASKS_REVIEW, TASKS_APPROVED, TASKS_NEEDS_CHANGES,
+#                   TASKS_MERGED, TASKS_ATTENTION
+
+# Prevent double-sourcing
+[[ -n "${_DAEMON_STATE_LOADED:-}" ]] && return 0
+_DAEMON_STATE_LOADED=1
+
+# Node.js frontmatter helper (RT-20260405-001 MEDIUM-5: replaces grep/cut YAML parsing)
+FRONTMATTER_JS="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)/frontmatter.js"
+
+# Parse a single frontmatter field from a markdown file.
+# Usage: fm_field <file> <field>
+fm_field() {
+    node "$FRONTMATTER_JS" "$1" "$2" 2>/dev/null | sed -n "s/^${2}=//p"
+}
+
+# Parse a markdown section's first content line.
+# Usage: fm_section <file> <heading>
+fm_section() {
+    node "$FRONTMATTER_JS" --section "$1" "$2" 2>/dev/null
+}
+
+update_state() {
+    # Count tasks in each folder (using find with -maxdepth for safety)
+    local pending in_progress completed review approved needs_changes merged attention
+    pending=$(find "$FORGE_ROOT/$TASKS_PENDING" -maxdepth 1 -name "*.md" -type f 2>/dev/null | wc -l)
+    in_progress=$(find "$FORGE_ROOT/$TASKS_IN_PROGRESS" -maxdepth 1 -name "*.md" -type f 2>/dev/null | wc -l)
+    completed=$(find "$FORGE_ROOT/$TASKS_COMPLETED" -maxdepth 1 -name "*.md" -type f 2>/dev/null | wc -l)
+    review=$(find "$FORGE_ROOT/$TASKS_REVIEW" -maxdepth 1 -name "*.md" -type f 2>/dev/null | wc -l)
+    approved=$(find "$FORGE_ROOT/$TASKS_APPROVED" -maxdepth 1 -name "*.md" -type f 2>/dev/null | wc -l)
+    needs_changes=$(find "$FORGE_ROOT/$TASKS_NEEDS_CHANGES" -maxdepth 1 -name "*.md" -type f 2>/dev/null | wc -l)
+    merged=$(find "$FORGE_ROOT/$TASKS_MERGED" -maxdepth 1 -name "*.md" -type f 2>/dev/null | wc -l)
+    attention=$(find "$FORGE_ROOT/$TASKS_ATTENTION" -maxdepth 1 -name "*.md" -type f 2>/dev/null | wc -l)
+
+    local blocked=${BLOCKED_TASK_COUNT:-0}
+
+    # Build active task details for in-progress tasks
+    local active_tasks_details=""
+    if [[ "$in_progress" -gt 0 ]]; then
+        active_tasks_details=$(build_active_tasks)
+    fi
+
+    # Build attention details if any workers need help
+    local attention_details=""
+    if [[ "$attention" -gt 0 ]]; then
+        attention_details=$(build_attention_details)
+    fi
+
+    # Build blocked task details (T2-H2)
+    local blocked_details=""
+    if [[ "$blocked" -gt 0 ]]; then
+        blocked_details=$(build_blocked_tasks)
+    fi
+
+    # Build worker status from agent-status files
+    local worker_status=""
+    if [[ -d "$FORGE_ROOT/$AGENT_STATUS_DIR" ]]; then
+        worker_status=$(build_worker_status)
+    fi
+
+    # Write state file atomically (write to temp, then move)
+    local temp_state="${STATE_FILE}.tmp.$$"
+    cat > "$temp_state" << EOF
+# Vibe Forge State
+# Auto-updated by forge-daemon
+# Last updated: $(date -Iseconds)
+
+forge:
+  status: active
+  daemon_pid: $$
+
+tasks:
+  pending: $pending
+  in_progress: $in_progress
+  completed: $completed
+  in_review: $review
+  approved: $approved
+  needs_changes: $needs_changes
+  merged: $merged
+  blocked: $blocked
+  attention_needed: $attention
+
+$active_tasks_details
+$attention_details
+$blocked_details
+$worker_status
+last_updated: $(date -Iseconds)
+EOF
+    mv "$temp_state" "$STATE_FILE"
+}
+
+build_attention_details() {
+    echo "attention:"
+    for attention_file in "$FORGE_ROOT/$TASKS_ATTENTION"/*.md; do
+        if [[ -f "$attention_file" && ! -L "$attention_file" ]]; then
+            local agent created issue
+            agent=$(fm_field "$attention_file" "agent")
+            created=$(fm_field "$attention_file" "created")
+            issue=$(fm_section "$attention_file" "Issue")
+            issue="${issue:-Needs attention}"
+
+            printf '  - agent: %s\n' "$agent"
+            printf '    since: %s\n' "$created"
+            printf '    issue: "%s"\n' "$issue"
+        fi
+    done
+}
+
+build_active_tasks() {
+    echo "active_tasks:"
+    for task_file in "$FORGE_ROOT/$TASKS_IN_PROGRESS"/*.md; do
+        if [[ -f "$task_file" && ! -L "$task_file" ]]; then
+            local task_id title assigned_to
+            task_id=$(fm_field "$task_file" "id")
+            title=$(fm_field "$task_file" "title")
+            assigned_to=$(fm_field "$task_file" "assigned_to")
+
+            task_id="${task_id:-$(basename "$task_file" .md)}"
+            title="${title:-Untitled}"
+            assigned_to="${assigned_to:-unassigned}"
+
+            printf '  - id: %s\n' "$task_id"
+            printf '    title: "%s"\n' "$title"
+            printf '    assigned_to: %s\n' "$assigned_to"
+        fi
+    done
+}
+
+# Determine daemon state based on activity (for adaptive polling)
+determine_daemon_state() {
+    # Check if there are in-progress tasks
+    local in_progress_count
+    in_progress_count=$(find "$FORGE_ROOT/$TASKS_IN_PROGRESS" -maxdepth 1 -name "*.md" -type f 2>/dev/null | wc -l)
+
+    # Check if there are active workers
+    local active_workers
+    active_workers=$(db_count_active_workers 2>/dev/null || echo "0")
+
+    if [[ "$in_progress_count" -gt 0 ]] || [[ "$active_workers" -gt 0 ]]; then
+        echo "active"
+    else
+        echo "idle"
+    fi
+}
+
+# Get current poll interval in seconds (from DB, with fallback)
+get_poll_interval() {
+    local interval_ms
+    interval_ms=$(db_get_poll_interval_ms 2>/dev/null || echo "30000")
+    # Convert ms to seconds (bash integer division)
+    echo $((interval_ms / 1000))
+}

package/src/lib/daemon/sync.sh

@@ -0,0 +1,103 @@
+#!/usr/bin/env bash
+#
+# src/lib/daemon/sync.sh
+#
+# Agent status synchronization functions - JSON files to SQLite
+#
+# Dependencies: json.sh, database.sh, constants.sh
+# Globals required: FORGE_ROOT, FORGE_DB, AGENT_STATUS_DIR, LOG_FILE,
+#                   STALE_STATUS_THRESHOLD
+
+# Prevent double-sourcing
+[[ -n "${_DAEMON_SYNC_LOADED:-}" ]] && return 0
+_DAEMON_SYNC_LOADED=1
+
+# Sync agent status from JSON files to SQLite (with mtime filtering)
+sync_agent_status_to_db() {
+    local status_dir="$FORGE_ROOT/$AGENT_STATUS_DIR"
+
+    if [[ ! -d "$status_dir" ]]; then
+        return 0
+    fi
+
+    for status_file in "$status_dir"/*.json; do
+        if [[ -f "$status_file" && ! -L "$status_file" ]]; then
+            # Get file modification time
+            local file_mtime
+            file_mtime=$(stat -c %Y "$status_file" 2>/dev/null || stat -f %m "$status_file" 2>/dev/null || echo "0")
+
+            # Get agent name from filename
+            local agent_name
+            agent_name=$(basename "$status_file" .json)
+
+            # Check if file has changed since last read
+            local stored_mtime
+            stored_mtime=$(db_get_agent_mtime "$agent_name")
+
+            if [[ "$file_mtime" -gt "$stored_mtime" ]]; then
+                # File changed - parse and update DB
+                local agent status task message updated
+                agent=$(json_read "$status_file" "agent" "unknown")
+                status=$(json_read "$status_file" "status" "unknown")
+                task=$(json_read "$status_file" "task" "")
+                message=$(json_read "$status_file" "message" "" | head -c 80)
+                updated=$(json_read "$status_file" "updated" "")
+
+                # Check if status actually changed (T1-D3: record transitions)
+                local old_status
+                old_status=$(sqlite3 "$FORGE_DB" \
+                    "SELECT status FROM agent_status WHERE agent = '$(db_escape "$agent")';" 2>/dev/null || echo "")
+                if [[ "$old_status" != "$status" && -n "$status" ]]; then
+                    db_record_status_history "$agent" "$status" "$task"
+                fi
+
+                # Upsert to database
+                db_upsert_agent_status "$agent" "$status" "$task" "$message" "$updated" "$file_mtime"
+
+                echo "[$(date -Iseconds)] Synced status for $agent: $status" >> "$LOG_FILE"
+            fi
+        fi
+    done
+}
+
+# Build worker status from SQLite (for YAML output)
+build_worker_status() {
+    local now_epoch
+    now_epoch=$(date +%s)
+    local stale_threshold=$STALE_STATUS_THRESHOLD
+
+    # Check if we have any agent status in DB
+    local agent_count
+    agent_count=$(sqlite3 "$FORGE_DB" "SELECT COUNT(*) FROM agent_status;" 2>/dev/null || echo "0")
+
+    if [[ "$agent_count" -eq 0 ]]; then
+        return 0
+    fi
+
+    echo "workers:"
+
+    # Read from database
+    while IFS='|' read -r agent status task message updated; do
+        local stale_marker=""
+
+        # Check if stale
+        if [[ -n "$updated" ]]; then
+            local updated_epoch age
+            updated_epoch=$(date -d "$updated" +%s 2>/dev/null || date -j -f "%Y-%m-%dT%H:%M:%S" "${updated%Z}" +%s 2>/dev/null || echo "0")
+            age=$((now_epoch - updated_epoch))
+            if [[ "$age" -gt "$stale_threshold" ]]; then
+                stale_marker=" (stale)"
+            fi
+        fi
+
+        echo "  - agent: $agent"
+        echo "    status: $status$stale_marker"
+        if [[ -n "$task" ]]; then
+            echo "    task: $task"
+        fi
+        if [[ -n "$message" ]]; then
+            echo "    message: \"$message\""
+        fi
+        echo "    updated: $updated"
+    done < <(db_get_all_agent_statuses)
+}

package/{bin → src}/lib/database.sh

@@ -51,10 +51,57 @@ db_require_init() {
     return 0
 }
 
+# Check if sqlite3 is available; attempt install if missing
+db_require_sqlite3() {
+    if command -v sqlite3 &>/dev/null; then
+        return 0
+    fi
+
+    echo "sqlite3 not found. Attempting to install..." >&2
+
+    # Try platform-appropriate package manager
+    if command -v apt-get &>/dev/null; then
+        echo "Installing sqlite3 via apt (may require sudo password)..." >&2
+        sudo apt-get install -y sqlite3 2>/dev/null && command -v sqlite3 &>/dev/null && return 0
+    elif command -v brew &>/dev/null; then
+        echo "Installing sqlite3 via Homebrew..." >&2
+        brew install sqlite3 2>/dev/null && command -v sqlite3 &>/dev/null && return 0
+    elif command -v pacman &>/dev/null; then
+        echo "Installing sqlite via pacman (may require sudo password)..." >&2
+        sudo pacman -S --noconfirm sqlite 2>/dev/null && command -v sqlite3 &>/dev/null && return 0
+    elif command -v dnf &>/dev/null; then
+        echo "Installing sqlite via dnf (may require sudo password)..." >&2
+        sudo dnf install -y sqlite 2>/dev/null && command -v sqlite3 &>/dev/null && return 0
+    elif command -v winget &>/dev/null; then
+        echo "Installing SQLite via winget. You may see a UAC prompt; please approve it." >&2
+        winget install --id SQLite.SQLite -e --silent 2>/dev/null
+        # winget installs to Program Files but doesn't add to Git Bash PATH
+        local winget_sqlite="/c/Program Files/SQLite/sqlite3.exe"
+        if [[ -f "$winget_sqlite" ]]; then
+            export PATH="$PATH:/c/Program Files/SQLite"
+            command -v sqlite3 &>/dev/null && return 0
+        fi
+    elif command -v choco &>/dev/null; then
+        echo "Installing sqlite via Chocolatey. You may see a UAC prompt; please approve it." >&2
+        choco install sqlite -y 2>/dev/null && command -v sqlite3 &>/dev/null && return 0
+    fi
+
+    echo "ERROR: sqlite3 is required but could not be installed automatically." >&2
+    echo "Please install sqlite3 manually:" >&2
+    echo "  macOS:   brew install sqlite3" >&2
+    echo "  Ubuntu:  sudo apt-get install sqlite3" >&2
+    echo "  Fedora:  sudo dnf install sqlite" >&2
+    echo "  Windows: choco install sqlite" >&2
+    echo "           or: winget install SQLite.SQLite" >&2
+    echo "           (then add the install folder to your PATH)" >&2
+    return 1
+}
+
 # Initialize the database with schema
 # Requires: FORGE_DB must be set before calling
 db_init() {
     db_require_init || return 1
+    db_require_sqlite3 || return 1
     local db_dir
     db_dir=$(dirname "$FORGE_DB")
 
@@ -62,6 +109,11 @@ db_init() {
     mkdir -p "$db_dir"
     chmod 700 "$db_dir"
 
+    # Enable WAL mode for concurrent reads without blocking writes.
+    # WAL + NORMAL synchronous is the recommended pairing for local tooling:
+    # faster than DELETE+FULL while still durable against OS crashes.
+    sqlite3 "$FORGE_DB" "PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL;"
+
     # Create tables if they don't exist
     sqlite3 "$FORGE_DB" <<'SQL'
 -- Daemon configuration (single row)

package/src/lib/frontmatter.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+/**
+ * frontmatter.js - Safe YAML frontmatter field extractor
+ *
+ * Replaces grep/cut pipelines for extracting frontmatter fields from
+ * task and attention markdown files (RT-20260405-001 MEDIUM-5).
+ *
+ * Usage:
+ *   node frontmatter.js <file> <field1> [field2] ...
+ *   node frontmatter.js --section <file> <heading>
+ *
+ * Output (field mode):
+ *   field1=value1
+ *   field2=value2
+ *
+ * Output (section mode):
+ *   First non-heading line under the matched ## heading
+ *
+ * Values are sanitized for safe shell consumption:
+ *   - Shell metacharacters removed
+ *   - Length capped at 200 chars
+ *   - Missing fields output as empty: field=
+ */
+
+'use strict';
+
+const fs = require('fs');
+const yaml = require('js-yaml');
+
+const MAX_VALUE_LENGTH = 200;
+
+// Strip characters unsafe for shell interpolation
+function sanitize(val) {
+    if (val == null) return '';
+    const str = String(val)
+        .replace(/[\0\r]/g, '')
+        .replace(/[\n]/g, ' ')
+        .replace(/[$`"'\\(){}[\]!#;|&<>]/g, '')
+        .trim();
+    return str.substring(0, MAX_VALUE_LENGTH);
+}
+
+function extractFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match) return {};
+    try {
+        const parsed = yaml.load(match[1]);
+        return typeof parsed === 'object' && parsed !== null ? parsed : {};
+    } catch (_) {
+        return {};
+    }
+}
+
+function extractSection(content, heading) {
+    const pattern = new RegExp(`^## ${heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 'im');
+    const idx = content.search(pattern);
+    if (idx === -1) return '';
+    const after = content.substring(idx).split('\n').slice(1);
+    for (const line of after) {
+        if (line.startsWith('## ')) break;
+        const trimmed = line.trim();
+        if (trimmed) return sanitize(trimmed);
+    }
+    return '';
+}
+
+// Main
+const args = process.argv.slice(2);
+
+if (args.length < 2) {
+    process.stderr.write('Usage: node frontmatter.js <file> <field1> [field2] ...\n');
+    process.stderr.write('       node frontmatter.js --section <file> <heading>\n');
+    process.exit(1);
+}
+
+// Section mode: --section <file> <heading>
+if (args[0] === '--section') {
+    const file = args[1];
+    const heading = args[2];
+    if (!file || !heading) {
+        process.stderr.write('Usage: node frontmatter.js --section <file> <heading>\n');
+        process.exit(1);
+    }
+    let content;
+    try { content = fs.readFileSync(file, 'utf8'); } catch (_) { process.exit(0); }
+    process.stdout.write(extractSection(content, heading) + '\n');
+    process.exit(0);
+}
+
+// Field mode: <file> <field1> [field2] ...
+const file = args[0];
+const fields = args.slice(1);
+
+let content;
+try { content = fs.readFileSync(file, 'utf8'); } catch (_) {
+    // File unreadable: output empty values
+    for (const f of fields) process.stdout.write(`${f}=\n`);
+    process.exit(0);
+}
+
+const data = extractFrontmatter(content);
+
+for (const field of fields) {
+    const val = sanitize(data[field]);
+    process.stdout.write(`${field}=${val}\n`);
+}

package/src/lib/heimdall-setup.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+/**
+ * Heimdall Setup -- writes .claude/settings.local.json into a worker's
+ * working directory to register Heimdall as a PreToolUse hook.
+ *
+ * Called by the forge daemon at inbox-write time, before the worker
+ * picks up a lab task.
+ *
+ * Uses a merge strategy: if settings.local.json already exists, the
+ * Heimdall hooks are merged into the existing PreToolUse array rather
+ * than overwriting the file.
+ */
+
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+
+// Absolute path to heimdall.js -- resolvable from any working directory
+const HEIMDALL_PATH = path.resolve(__dirname, 'heimdall.js').replace(/\\/g, '/')
+
+const HEIMDALL_HOOKS = ['Bash', 'Write', 'Edit'].map(matcher => ({
+  matcher,
+  hooks: [{ type: 'command', command: `node "${HEIMDALL_PATH}"` }],
+}))
+
+/**
+ * writeHeimdallHooks(worktreePath)
+ *
+ * Writes or merges Heimdall PreToolUse hooks into:
+ *   <worktreePath>/.claude/settings.local.json
+ *
+ * Safe to call multiple times -- idempotent.
+ *
+ * @param {string} worktreePath  Absolute path to the worker's worktree root
+ */
+function writeHeimdallHooks(worktreePath) {
+  const claudeDir = path.join(worktreePath, '.claude')
+  const settingsPath = path.join(claudeDir, 'settings.local.json')
+
+  // Ensure .claude/ exists
+  if (!fs.existsSync(claudeDir)) {
+    fs.mkdirSync(claudeDir, { recursive: true })
+  }
+
+  // Read existing settings if present
+  let existing = {}
+  if (fs.existsSync(settingsPath)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(settingsPath, 'utf8'))
+    } catch (_) {
+      // Corrupt file -- start fresh
+      existing = {}
+    }
+  }
+
+  // Ensure hooks structure exists
+  if (!existing.hooks) existing.hooks = {}
+  if (!existing.hooks.PreToolUse) existing.hooks.PreToolUse = []
+
+  // Merge: add Heimdall hook entries for matchers not already registered
+  const existingMatchers = new Set(
+    existing.hooks.PreToolUse.map(h => h.matcher)
+  )
+
+  for (const heimdallHook of HEIMDALL_HOOKS) {
+    if (!existingMatchers.has(heimdallHook.matcher)) {
+      existing.hooks.PreToolUse.push(heimdallHook)
+    }
+  }
+
+  fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + '\n')
+}
+
+/**
+ * writeContextFile(worktreePath, context)
+ *
+ * Writes the Heimdall context file to the worktree root so Heimdall
+ * can read per-task policy on every invocation.
+ *
+ * @param {string} worktreePath  Absolute path to the worker's worktree root
+ * @param {object} context       Context object matching the schema below
+ *
+ * Context schema:
+ * {
+ *   story_id:       string   -- lab story ID (e.g. "FORGE-3")
+ *   agent:          string   -- worker name (e.g. "anvil")
+ *   worktree_path:  string   -- absolute path to worktree (same as worktreePath)
+ *   assigned_branch: string  -- git branch for this story
+ *   handoff_dir:    string   -- absolute path to _vibe-chain-output/handoffs/
+ *   escalation_dir: string   -- absolute path to worker-inbox/<agent>/ dir
+ *   audit_log:      string   -- absolute path to heimdall-audit.log
+ *   has_db_migration: boolean
+ *   has_api_changes:  boolean
+ *   allowed_paths:  string[] -- absolute paths the worker may read/write
+ * }
+ */
+function writeContextFile(worktreePath, context) {
+  const contextPath = path.join(worktreePath, '.context.json')
+  fs.writeFileSync(contextPath, JSON.stringify(context, null, 2) + '\n')
+}
+
+/**
+ * setup(worktreePath, context)
+ *
+ * Convenience function: writes both hooks and context file in one call.
+ */
+function setup(worktreePath, context) {
+  writeHeimdallHooks(worktreePath)
+  writeContextFile(worktreePath, context)
+}
+
+module.exports = { setup, writeHeimdallHooks, writeContextFile, HEIMDALL_PATH }