@askexenow/exe-os 0.9.294 → 0.9.296

package/dist/pipeline-router-WWSZVPCH.js

@@ -0,0 +1,15 @@
+import {
+  ingest
+} from "./chunk-XJZBSTL5.js";
+import "./chunk-WUKHLCBE.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-2E43UXRH.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-7HLWBYH7.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-R36FAN53.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  ingest
+};

package/dist/plan-limits-C7XCSDZC.js

@@ -0,0 +1,28 @@
+import {
+  PlanLimitError,
+  assertEmployeeLimit,
+  assertEmployeeLimitSync,
+  assertFeature,
+  assertMemoryLimit,
+  countActiveMemories,
+  getLicenseSync
+} from "./chunk-5CCXU2AW.js";
+import "./chunk-WUKHLCBE.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-2E43UXRH.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-7HLWBYH7.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-YTKVJJSU.js";
+import "./chunk-R36FAN53.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  PlanLimitError,
+  assertEmployeeLimit,
+  assertEmployeeLimitSync,
+  assertFeature,
+  assertMemoryLimit,
+  countActiveMemories,
+  getLicenseSync
+};

package/dist/project-boot-N3NTBVLE.js

@@ -0,0 +1,299 @@
+import {
+  EXE_AI_DIR
+} from "./chunk-R36FAN53.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/bin/project-boot.ts
+import path from "path";
+import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import net from "net";
+var DAEMON_URL = "http://127.0.0.1:48739";
+var EXE_DIR = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path.join(process.env.HOME ?? "/tmp", ".exe-os");
+var SOCK_PATH = path.join(EXE_DIR, "exed.sock");
+var TOKEN_PATH = path.join(EXE_DIR, "exed.token");
+function getDaemonToken() {
+  try {
+    if (!existsSync(TOKEN_PATH)) return null;
+    return readFileSync(TOKEN_PATH, "utf-8").trim();
+  } catch {
+    return null;
+  }
+}
+function detectProject() {
+  try {
+    const root = execSync("git rev-parse --show-toplevel 2>/dev/null", {
+      encoding: "utf8",
+      timeout: 3e3
+    }).trim();
+    if (root) return path.basename(root);
+  } catch {
+  }
+  return null;
+}
+function formatTimeAgo(isoTimestamp) {
+  const then = new Date(isoTimestamp).getTime();
+  if (Number.isNaN(then)) return "unknown";
+  const diffMs = Date.now() - then;
+  const diffMinutes = Math.floor(diffMs / 6e4);
+  if (diffMinutes < 60) return `${diffMinutes}m ago`;
+  const diffHours = Math.floor(diffMinutes / 60);
+  if (diffHours < 48) return `${diffHours}h ago`;
+  const diffDays = Math.floor(diffHours / 24);
+  return `${diffDays}d ago`;
+}
+function getLastCommit() {
+  try {
+    return execSync("git log --oneline -1 2>/dev/null", {
+      encoding: "utf8",
+      timeout: 3e3
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function getGitBranch() {
+  try {
+    return execSync("git branch --show-current 2>/dev/null", {
+      encoding: "utf8",
+      timeout: 3e3
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function projectBoot(options) {
+  const startTime = performance.now();
+  const project = options.project || detectProject();
+  if (!project) {
+    return "Error: No --project specified and could not detect project from git repo.\nUsage: exe-os boot --project <name>";
+  }
+  const agentId = process.env.AGENT_ID || "default";
+  const testDbClient = process.env.VITEST === "true" || process.env.NODE_ENV === "test" ? (await import("./lib/database.js")).getClient() : null;
+  const daemonQuery = (sql, args) => {
+    if (testDbClient) {
+      return Promise.resolve(testDbClient.execute({ sql, args }));
+    }
+    return new Promise((resolve, reject) => {
+      if (!existsSync(SOCK_PATH)) {
+        reject(new Error("Daemon socket not found"));
+        return;
+      }
+      const sock = net.createConnection(SOCK_PATH);
+      const id = `boot-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+      let buf = "";
+      const timeout = setTimeout(() => {
+        sock.destroy();
+        reject(new Error("timeout"));
+      }, 5e3);
+      sock.on("connect", () => {
+        const token = getDaemonToken();
+        sock.write(JSON.stringify({ id, type: "db-execute", sql, args, token }) + "\n");
+      });
+      sock.on("data", (chunk) => {
+        buf += chunk.toString();
+        const lines = buf.split("\n");
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed.id === id) {
+              clearTimeout(timeout);
+              sock.destroy();
+              if (parsed.error) {
+                reject(new Error(String(parsed.error)));
+                return;
+              }
+              const db = parsed.db;
+              resolve({ rows: db?.rows ?? [] });
+            }
+          } catch {
+          }
+        }
+      });
+      sock.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+    });
+  };
+  const lastCommit = getLastCommit();
+  const gitBranch = getGitBranch();
+  let workingMemoryResult = 0;
+  let behaviorResult = { total: 0, p0: 0, p1: 0 };
+  let identityInfo;
+  let lastSessionResult = null;
+  let daemonResult = { healthy: false, pid: null };
+  let totalMemoryResult = 0;
+  let openTasksResult = 0;
+  try {
+    const results = await Promise.all([
+      // Working memory count
+      daemonQuery("SELECT COUNT(*) as cnt FROM memories WHERE project_name = ? AND importance >= 7", [project]).then((r) => Number(r.rows[0]?.cnt) || 0).catch(() => 0),
+      // Behavior counts
+      daemonQuery("SELECT priority, COUNT(*) as cnt FROM behaviors WHERE active = 1 AND agent_id = ? GROUP BY priority", [agentId]).then((r) => {
+        let total = 0, p0 = 0, p1 = 0;
+        for (const row2 of r.rows) {
+          const count = Number(row2.cnt) || 0;
+          total += count;
+          const pri = String(row2.priority ?? "p1").toLowerCase();
+          if (pri === "p0") p0 = count;
+          else if (pri === "p1") p1 = count;
+        }
+        return { total, p0, p1 };
+      }).catch(() => ({ total: 0, p0: 0, p1: 0 })),
+      // Identity — from file (fast, no DB)
+      (async () => {
+        try {
+          const identityFile = path.join(EXE_AI_DIR, "identity", `${agentId}.md`);
+          if (existsSync(identityFile)) {
+            const raw = readFileSync(identityFile, "utf-8");
+            const titleMatch = raw.match(/^title:\s*(.+)/m);
+            const roleMatch = raw.match(/^role:\s*(.+)/m);
+            return { found: true, display: titleMatch?.[1]?.trim() || roleMatch?.[1]?.trim() || "unknown" };
+          }
+          return { found: false, display: "unknown" };
+        } catch {
+          return { found: false, display: "unknown" };
+        }
+      })(),
+      // Last session summary
+      daemonQuery(
+        `SELECT raw_text, timestamp FROM memories
+         WHERE project_name = ?
+         AND (raw_text LIKE '%CONTEXT CHECKPOINT%' OR raw_text LIKE '%CONTEXT COMMIT%'
+              OR raw_text LIKE '%session-end%' OR raw_text LIKE '%session-handoff%'
+              OR raw_text LIKE '%Snapshot saved%' OR memory_type = 'commit_to_long_term_memory')
+         ORDER BY timestamp DESC LIMIT 1`,
+        [project]
+      ).then((r) => {
+        if (r.rows.length > 0) {
+          return {
+            text: String(r.rows[0].raw_text ?? r.rows[0].text ?? ""),
+            timestamp: String(r.rows[0].timestamp ?? r.rows[0].created_at ?? "")
+          };
+        }
+        return null;
+      }).catch(() => null),
+      // Daemon health — if we got this far, daemon socket is alive.
+      // Extract PID from daemon ping via HTTP (lightweight, non-blocking).
+      (async () => {
+        try {
+          const r = await fetch(`${DAEMON_URL}/v1/ping`, { signal: AbortSignal.timeout(3e3) });
+          if (r.ok) {
+            const data = await r.json();
+            return { healthy: true, pid: data.pid ?? null };
+          }
+        } catch {
+        }
+        if (process.env.VITEST === "true" || process.env.NODE_ENV === "test") {
+          return { healthy: false, pid: null };
+        }
+        return { healthy: true, pid: null };
+      })(),
+      // Total active memories — match memory(action='cardinality') so the boot
+      // brief cannot inflate counts by including deleted/archived rows.
+      daemonQuery("SELECT COUNT(*) as cnt FROM memories WHERE COALESCE(status, 'active') = 'active'", []).then((r) => Number(r.rows[0]?.cnt) || 0).catch(() => 0),
+      // Open tasks
+      daemonQuery(
+        "SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status IN ('open', 'in_progress') AND project_name = ?",
+        [agentId, project]
+      ).then((r) => Number(r.rows[0]?.cnt) || 0).catch(() => 0)
+    ]);
+    workingMemoryResult = results[0];
+    behaviorResult = results[1];
+    identityInfo = results[2];
+    lastSessionResult = results[3];
+    daemonResult = results[4];
+    totalMemoryResult = results[5];
+    openTasksResult = results[6];
+  } catch (err) {
+    const elapsed2 = ((performance.now() - startTime) / 1e3).toFixed(1);
+    return [
+      `Boot failed for project: ${project}`,
+      `Daemon unavailable: ${err instanceof Error ? err.message : String(err)}`,
+      `Start daemon: exe-os update`,
+      `Failed in ${elapsed2}s`
+    ].join("\n");
+  }
+  const elapsed = ((performance.now() - startTime) / 1e3).toFixed(1);
+  let sessionLine;
+  if (lastSessionResult) {
+    const timeAgo = formatTimeAgo(lastSessionResult.timestamp);
+    const lines = lastSessionResult.text.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
+    const preview = (lines[0] || lastSessionResult.text).slice(0, 80);
+    sessionLine = `${timeAgo} \u2014 ${preview}${preview.length >= 80 ? "..." : ""}`;
+  } else {
+    sessionLine = "no previous session found";
+  }
+  let autoFixLine = "no recent cycles";
+  try {
+    const { execSync: exec } = await import("child_process");
+    const openPRs = exec("gh pr list --state open --label auto-fix --json number,title,createdAt 2>/dev/null || echo '[]'", {
+      encoding: "utf8",
+      timeout: 5e3
+    }).trim();
+    const open = JSON.parse(openPRs || "[]");
+    const mergedPRs = exec("gh pr list --state merged --label auto-fix --limit 3 --json number,title,mergedAt 2>/dev/null || echo '[]'", {
+      encoding: "utf8",
+      timeout: 5e3
+    }).trim();
+    const merged = JSON.parse(mergedPRs || "[]");
+    if (open.length > 0) {
+      autoFixLine = `\u{1F527} PR #${open[0].number} open (${formatTimeAgo(open[0].createdAt)})`;
+    } else if (merged.length > 0) {
+      autoFixLine = `\u2705 PR #${merged[0].number} merged ${formatTimeAgo(merged[0].mergedAt)}`;
+    }
+  } catch {
+  }
+  const rows = [
+    ["Memory", `${workingMemoryResult.toLocaleString()} working`, `${totalMemoryResult.toLocaleString()} total`],
+    ["Behaviors", `${behaviorResult.total} active`, `${behaviorResult.p0} p0, ${behaviorResult.p1} p1`],
+    ["Identity", identityInfo.found ? `\u2705 ${agentId}` : `\u274C ${agentId}`, identityInfo.display],
+    ["Daemon", daemonResult.healthy ? `\u2705 healthy` : `\u274C unhealthy`, daemonResult.pid ? `PID ${daemonResult.pid}` : "run: exe-os healthcheck"],
+    ["Last session", sessionLine.slice(0, 60), sessionLine.length > 60 ? sessionLine.slice(60, 120) : ""]
+  ];
+  if (lastCommit) {
+    const commitShort = lastCommit.length > 50 ? lastCommit.slice(0, 50) + "..." : lastCommit;
+    rows.push(["Last commit", commitShort, gitBranch ?? ""]);
+  }
+  if (openTasksResult > 0) {
+    rows.push(["Open tasks", `${openTasksResult} pending`, ""]);
+  }
+  rows.push(["Auto-fix", autoFixLine, ""]);
+  const col1W = Math.max(14, ...rows.map((r) => r[0].length)) + 2;
+  const col2W = Math.max(20, ...rows.map((r) => r[1].length)) + 2;
+  const col3W = Math.max(15, ...rows.map((r) => r[2].length)) + 2;
+  const row = (a, b, c) => "\u2502" + ` ${a}`.padEnd(col1W) + "\u2502" + ` ${b}`.padEnd(col2W) + "\u2502" + ` ${c}`.padEnd(col3W) + "\u2502";
+  const report = [
+    "",
+    `  \u{1F680} exe-os boot \u2014 ${project} (${elapsed}s)`,
+    "",
+    "  \u250C" + "\u2500".repeat(col1W) + "\u252C" + "\u2500".repeat(col2W) + "\u252C" + "\u2500".repeat(col3W) + "\u2510",
+    "  " + row("Item", "Status", "Details"),
+    "  \u251C" + "\u2500".repeat(col1W) + "\u253C" + "\u2500".repeat(col2W) + "\u253C" + "\u2500".repeat(col3W) + "\u2524"
+  ];
+  for (const [a, b, c] of rows) {
+    report.push("  " + row(a, b, c));
+  }
+  report.push("  \u2514" + "\u2500".repeat(col1W) + "\u2534" + "\u2500".repeat(col2W) + "\u2534" + "\u2500".repeat(col3W) + "\u2518");
+  report.push("");
+  return report.join("\n");
+}
+function parseBootArgs(argv) {
+  const options = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--project" && argv[i + 1]) {
+      options.project = argv[++i];
+    } else if (arg.startsWith("--project=")) {
+      options.project = arg.slice("--project=".length);
+    }
+  }
+  return options;
+}
+export {
+  parseBootArgs,
+  projectBoot
+};