@matt82198/aesop 0.1.0-beta.1

package/monitor/collect-signals.mjs

@@ -0,0 +1,137 @@
+// Orchestration Refinement Monitor — deterministic signal collector (no LLM).
+// Walks known roots and emits a compact BRIEF.md + SIGNALS.json the Haiku monitor reads
+// each cycle, so its reasoning stays cheap and focused. Node built-ins only.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+
+const AESOP_ROOT = process.env.AESOP_ROOT || '.';
+const MON = path.join(AESOP_ROOT, 'monitor');
+const now = Date.now();
+const HOUR = 3600e3;
+const DAY = 24 * HOUR;
+
+const sh = (cmd, cwd) => {
+  try {
+    return execSync(cmd, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch {
+    return '';
+  }
+};
+
+const stat = (p) => {
+  try {
+    return fs.statSync(p);
+  } catch {
+    return null;
+  }
+};
+
+const age = (ms) => {
+  if (ms < HOUR) return `${Math.round(ms / 60e3)}m`;
+  if (ms < DAY) return `${(ms / HOUR).toFixed(1)}h`;
+  return `${(ms / DAY).toFixed(1)}d`;
+};
+
+// Main signal collection
+const signals = {
+  heartbeats: [],
+  rotations: [],
+  unreviewedPrompts: 0,
+  staleMemories: [],
+  respawnWatch: [],
+};
+
+const brief = [
+  `# Aesop Monitor Brief — ${new Date(now).toISOString()}`,
+  '',
+  '## Status',
+  'Orchestration monitor cycle complete.',
+  '',
+];
+
+// 1) Heartbeat check
+const beatsDir = path.join(MON, '.heartbeats');
+let beatFiles = [];
+try {
+  const files = fs.readdirSync(beatsDir);
+  beatFiles = files.map((f) => path.join(beatsDir, f));
+} catch {}
+
+const legacyBeats = [
+  path.join(MON, '.monitor-heartbeat'),
+  path.join(AESOP_ROOT, 'state', '.watchdog-heartbeat'),
+];
+
+beatFiles = beatFiles.concat(legacyBeats.filter((f) => fs.existsSync(f)));
+
+for (const fp of beatFiles) {
+  try {
+    const content = fs.readFileSync(fp, 'utf8').trim();
+    const epoch = parseInt(content.split('\n')[0], 10);
+    if (!epoch) continue;
+
+    const beatAge = now - epoch * 1000;
+    const name = path.basename(fp);
+    const thresholds = { watchdog: 300e3, monitor: 3600e3, default: 1800e3 };
+    let threshold = thresholds.default;
+    if (name.includes('watchdog')) threshold = thresholds.watchdog;
+    if (name.includes('monitor')) threshold = thresholds.monitor;
+
+    signals.heartbeats.push({
+      name,
+      ageMs: beatAge,
+      threshold,
+      ok: beatAge < threshold,
+    });
+  } catch {}
+}
+
+brief.push('## Heartbeats');
+if (signals.heartbeats.length === 0) {
+  brief.push('No heartbeats detected yet.');
+} else {
+  for (const hb of signals.heartbeats) {
+    const status = hb.ok ? '✓' : '✗';
+    brief.push(`- ${status} ${hb.name}: ${age(hb.ageMs)}`);
+  }
+}
+brief.push('');
+
+// 2) Log file status
+brief.push('## Logs');
+const logFiles = [
+  path.join(AESOP_ROOT, 'state', 'FLEET-BACKUP.log'),
+  path.join(AESOP_ROOT, 'state', 'SECURITY-ALERTS.log'),
+];
+
+for (const logFile of logFiles) {
+  const st = stat(logFile);
+  if (st) {
+    brief.push(`- ${path.basename(logFile)}: ${st.size} bytes`);
+  } else {
+    brief.push(`- ${path.basename(logFile)}: (not found)`);
+  }
+}
+brief.push('');
+
+// 3) Placeholder for future signal collectors
+brief.push('## Notes');
+brief.push('This is a template monitor. Extend collect-signals.mjs to add:');
+brief.push('- Junk-script sprawl detection');
+brief.push('- Memory gap detection');
+brief.push('- Rule friction analysis');
+brief.push('- Orchestration health checks');
+brief.push('');
+
+// Write outputs
+try {
+  fs.mkdirSync(MON, { recursive: true });
+  fs.writeFileSync(path.join(MON, 'BRIEF.md'), brief.join('\n'), 'utf8');
+  fs.writeFileSync(path.join(MON, 'SIGNALS.json'), JSON.stringify(signals, null, 2), 'utf8');
+  console.log('Monitor signals collected. See BRIEF.md and SIGNALS.json.');
+} catch (e) {
+  console.error('Failed to write signals:', e.message);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@matt82198/aesop",
+  "version": "0.1.0-beta.1",
+  "description": "Multi-agent orchestration for AI coding agents, designed to survive failure — a plain-file brain, git as the only durable layer, cheap subagent fleets, and guardrails enforced in code.",
+  "bin": {
+    "aesop": "bin/cli.js"
+  },
+  "type": "commonjs",
+  "files": [
+    "bin/",
+    "daemons/",
+    "dash/",
+    "monitor/",
+    "tools/",
+    "ui/",
+    "docs/",
+    "aesop.config.example.json",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "ai-agents",
+    "llm",
+    "claude",
+    "orchestration",
+    "multi-agent",
+    "developer-tools",
+    "resilience",
+    "template"
+  ],
+  "license": "MIT",
+  "author": "Matt Culliton",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/matt82198/aesop.git"
+  },
+  "homepage": "https://github.com/matt82198/aesop",
+  "bugs": {
+    "url": "https://github.com/matt82198/aesop/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+  }
+}

package/tools/launch_tui.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""
+launch_tui.py — Open a bash TUI script in its own terminal window.
+
+Usage:
+  python launch_tui.py --script <path-to-bash-script> [--title <window-title>] [--pidfile <path>]
+
+Behavior:
+  - Finds a terminal (prefer Git Bash, else Windows Terminal wt.exe)
+  - Opens a NEW visible window running `bash <script>`
+  - Idempotent via pidfile: if process already running, prints "already running (pid N)"
+  - Always outputs exactly one line: spawned pid, already-running, or error
+  - Direct git-bash spawn avoids cmd /c start quoting bugs
+"""
+
+import argparse
+import os
+import sys
+import subprocess
+import shutil
+import time
+from pathlib import Path
+
+
+def find_terminal():
+    """
+    Locate a terminal executable.
+    Prefer Git Bash (process persists → pidfile valid), fallback to Windows Terminal.
+    Returns (terminal_path, command_builder_fn, is_wt_bool).
+    command_builder_fn(script_path, title) returns command list to spawn.
+    is_wt_bool: True if using wt.exe (needs bash process tracking); False if git-bash (stable pid).
+    """
+    git_bash = r"C:\Program Files\Git\git-bash.exe"
+    wt_exe = shutil.which("wt.exe")
+    bash_exe = r"C:\Program Files\Git\bin\bash.exe"
+
+    # Prefer Git Bash (its process persists, so pidfile/idempotency works)
+    if os.path.exists(git_bash):
+        def git_bash_cmd(script_path, title):
+            # Spawn git-bash.exe -c "bash '/path/to/script.sh'"
+            # Convert Windows path to POSIX: C:\Users\...\... -> /c/Users/...\...
+            script_abs = os.path.abspath(script_path)
+            script_posix = "/" + script_abs[0].lower() + script_abs[2:].replace("\\", "/")
+            return [git_bash, "-c", f"bash '{script_posix}'"]
+        return git_bash, git_bash_cmd, False
+
+    # Fallback to Windows Terminal (spawns and exits, so we track bash process instead)
+    if wt_exe and os.path.exists(bash_exe):
+        def wt_cmd(script_path, title):
+            cmd = [wt_exe]
+            if title:
+                cmd.extend(["-w", title])
+            # Start a new tab/window running bash with the script
+            cmd.extend(["-d", str(Path(script_path).parent), bash_exe, script_path])
+            return cmd
+        return wt_exe, wt_cmd, True
+
+    raise FileNotFoundError(
+        "Terminal not found. Tried: Git Bash at "
+        f"{git_bash}, Windows Terminal (wt.exe) with bash at {bash_exe}"
+    )
+
+
+def find_bash_process_by_script(script_path):
+    r"""
+    Find bash.exe process running the given script using PowerShell.
+    Searches for the script path in the bash process CommandLine.
+    Returns PID if found, None otherwise.
+    """
+    try:
+        script_abs = os.path.abspath(script_path)
+        # Bash processes may show the path in either Windows or POSIX format
+        # Try both: C:\Users\... and /c/Users/...
+        search_patterns = [
+            script_abs,  # Windows format: C:\Users\...
+            "/" + script_abs[0].lower() + script_abs[2:].replace("\\", "/"),  # POSIX: /c/Users/...
+        ]
+
+        # Use PowerShell to find bash process matching either path format
+        ps_cmd = (
+            f"$patterns = @('{script_abs}', '/{script_abs[0].lower()}{script_abs[2:].replace(chr(92), '/')}'); "
+            f"Get-CimInstance Win32_Process -Filter \"name='bash.exe'\" | "
+            f"Where-Object {{ $cmd = $_.CommandLine; $patterns | Where-Object {{ $cmd -like \"*$_*\" }} }} | "
+            f"Select-Object -First 1 -ExpandProperty ProcessId"
+        )
+        result = subprocess.run(
+            ["powershell", "-NoProfile", "-Command", ps_cmd],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            pid_str = result.stdout.strip()
+            if pid_str.isdigit():
+                return int(pid_str)
+        return None
+    except Exception:
+        return None
+
+
+def check_bash_running(script_path):
+    """
+    Check if bash is currently running the script by looking at running processes.
+    Returns True if any bash/git-bash process is active.
+    """
+    try:
+        result = subprocess.run(
+            ["tasklist"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        # If bash or git-bash is running, assume script might be active
+        return "bash.exe" in result.stdout or "git-bash.exe" in result.stdout
+    except Exception:
+        return False
+
+
+def is_pidfile_valid_and_recent(pidfile_path, script_path):
+    """
+    Check if pidfile exists, is recent (created in last 60 seconds),
+    and bash processes are running. This is an idempotency heuristic.
+    """
+    try:
+        if not pidfile_path.exists():
+            return False
+
+        mtime = os.path.getmtime(pidfile_path)
+        age = time.time() - mtime
+        # If pidfile is less than 60 seconds old and bash is running, assume still active
+        if age < 60 and check_bash_running(script_path):
+            with open(pidfile_path, "r") as f:
+                old_pid = f.read().strip()
+            return int(old_pid)
+
+        return False
+    except Exception:
+        return False
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Open a bash TUI script in its own terminal window.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--script",
+        required=True,
+        help="Path to bash script to run",
+    )
+    parser.add_argument(
+        "--title",
+        default=None,
+        help="Window title (optional)",
+    )
+    parser.add_argument(
+        "--pidfile",
+        default=None,
+        help="Path to pidfile for idempotency (optional)",
+    )
+
+    args = parser.parse_args()
+
+    script_path = args.script
+    title = args.title
+    pidfile = args.pidfile
+
+    # Validate script exists
+    if not os.path.exists(script_path):
+        print(f"ERROR: Script not found: {script_path}")
+        sys.exit(1)
+
+    # Check pidfile for idempotency
+    if pidfile:
+        pidfile_path = Path(pidfile)
+        old_pid = is_pidfile_valid_and_recent(pidfile_path, script_path)
+        if old_pid:
+            print(f"already running (pid {old_pid})")
+            sys.exit(0)
+
+    # Find terminal
+    try:
+        terminal_path, cmd_builder, is_wt = find_terminal()
+    except FileNotFoundError as e:
+        print(f"ERROR: {e}")
+        sys.exit(1)
+
+    # Build and spawn command
+    cmd = cmd_builder(script_path, title)
+
+    try:
+        # Windows process creation flags
+        DETACHED_PROCESS = 0x00000008
+        CREATE_NEW_PROCESS_GROUP = 0x00000200
+
+        # For git-bash: spawn detached so process persists after parent exits
+        # For wt.exe: spawn normally (it exits immediately anyway)
+        if is_wt:
+            creationflags = 0
+        else:
+            creationflags = DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP
+
+        # Spawn the process without waiting
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            stdin=subprocess.DEVNULL,
+            creationflags=creationflags,
+        )
+
+        # For git-bash, its pid persists and we can use it directly
+        if not is_wt:
+            new_pid = proc.pid
+        else:
+            # For wt.exe, find the actual bash process running the script
+            # Poll for bash process running the script (up to 2 seconds)
+            new_pid = None
+            for _ in range(20):  # 20 attempts * 0.1s = 2s max wait
+                new_pid = find_bash_process_by_script(script_path)
+                if new_pid:
+                    break
+                time.sleep(0.1)
+
+            if not new_pid:
+                print(f"ERROR: Failed to locate bash process for {script_path}")
+                sys.exit(1)
+
+        # Write pidfile if specified
+        if pidfile:
+            pidfile_path = Path(pidfile)
+            pidfile_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(pidfile_path, "w") as f:
+                f.write(str(new_pid))
+
+        print(f"spawned (pid {new_pid})")
+        sys.exit(0)
+
+    except Exception as e:
+        print(f"ERROR: Failed to spawn terminal: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()