@askexenow/exe-os 0.8.0

package/dist/lib/employees.js

@@ -0,0 +1,177 @@
+// src/lib/employees.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync2, symlinkSync, readlinkSync } from "fs";
+import { execSync } from "child_process";
+import path2 from "path";
+
+// src/lib/config.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { readFileSync, existsSync, renameSync } from "fs";
+import path from "path";
+import os from "os";
+function resolveDataDir() {
+  if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
+  if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
+  const newDir = path.join(os.homedir(), ".exe-os");
+  const legacyDir = path.join(os.homedir(), ".exe-mem");
+  if (!existsSync(newDir) && existsSync(legacyDir)) {
+    try {
+      renameSync(legacyDir, newDir);
+      process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
+`);
+    } catch {
+      return legacyDir;
+    }
+  }
+  return newDir;
+}
+var EXE_AI_DIR = resolveDataDir();
+var DB_PATH = path.join(EXE_AI_DIR, "memories.db");
+var MODELS_DIR = path.join(EXE_AI_DIR, "models");
+var CONFIG_PATH = path.join(EXE_AI_DIR, "config.json");
+var LEGACY_LANCE_PATH = path.join(EXE_AI_DIR, "local.lance");
+var CURRENT_CONFIG_VERSION = 1;
+var DEFAULT_CONFIG = {
+  config_version: CURRENT_CONFIG_VERSION,
+  dbPath: DB_PATH,
+  modelFile: "jina-embeddings-v5-small-q4_k_m.gguf",
+  embeddingDim: 1024,
+  batchSize: 20,
+  flushIntervalMs: 1e4,
+  autoIngestion: true,
+  autoRetrieval: true,
+  searchMode: "hybrid",
+  hookSearchMode: "hybrid",
+  fileGrepEnabled: true,
+  splashEffect: true,
+  consolidationEnabled: true,
+  consolidationIntervalMs: 6 * 60 * 60 * 1e3,
+  consolidationModel: "claude-haiku-4-5-20251001",
+  consolidationMaxCallsPerRun: 20,
+  selfQueryRouter: true,
+  selfQueryModel: "claude-haiku-4-5-20251001",
+  rerankerEnabled: true,
+  scalingRoadmap: {
+    rerankerAutoTrigger: {
+      enabled: true,
+      broadQueryMinCardinality: 5e4,
+      fetchTopK: 150,
+      returnTopK: 5
+    }
+  },
+  graphRagEnabled: true,
+  wikiEnabled: false,
+  wikiUrl: "",
+  wikiApiKey: "",
+  wikiSyncIntervalMs: 30 * 60 * 1e3,
+  wikiWorkspaceMapping: {
+    exe: "Executive",
+    yoshi: "Engineering",
+    mari: "Marketing",
+    tom: "Engineering",
+    sasha: "Production"
+  },
+  wikiAutoUpdate: true,
+  wikiAutoUpdateThreshold: 0.5,
+  wikiAutoUpdateCreateNew: true,
+  skillLearning: true,
+  skillThreshold: 3,
+  skillModel: "claude-haiku-4-5-20251001",
+  exeHeartbeat: {
+    enabled: true,
+    intervalSeconds: 60,
+    staleInProgressThresholdHours: 2
+  },
+  sessionLifecycle: {
+    idleKillEnabled: true,
+    idleKillTicksRequired: 3,
+    idleKillIntercomAckWindowMs: 1e4,
+    maxAutoInstances: 10
+  }
+};
+
+// src/lib/employees.ts
+var EMPLOYEES_PATH = path2.join(EXE_AI_DIR, "exe-employees.json");
+function validateEmployeeName(name) {
+  if (!name) {
+    return { valid: false, error: "Name is required" };
+  }
+  if (name.length > 32) {
+    return { valid: false, error: "Name must be 32 characters or fewer" };
+  }
+  if (!/^[a-z][a-z0-9]*$/.test(name)) {
+    return {
+      valid: false,
+      error: "Name must start with a letter and contain only lowercase alphanumeric characters"
+    };
+  }
+  return { valid: true };
+}
+async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync2(employeesPath)) {
+    return [];
+  }
+  const raw = await readFile2(employeesPath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
+  await mkdir2(path2.dirname(employeesPath), { recursive: true });
+  await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
+}
+function getEmployee(employees, name) {
+  return employees.find((e) => e.name === name);
+}
+function addEmployee(employees, employee) {
+  if (employees.some((e) => e.name === employee.name)) {
+    throw new Error(`Employee '${employee.name}' already exists`);
+  }
+  return [...employees, employee];
+}
+function registerBinSymlinks(name) {
+  const created = [];
+  const skipped = [];
+  const errors = [];
+  let exeBinPath;
+  try {
+    exeBinPath = execSync("which exe", { encoding: "utf-8" }).trim();
+  } catch {
+    errors.push("Could not find 'exe' in PATH");
+    return { created, skipped, errors };
+  }
+  const binDir = path2.dirname(exeBinPath);
+  let target;
+  try {
+    target = readlinkSync(exeBinPath);
+  } catch {
+    errors.push("Could not read 'exe' symlink");
+    return { created, skipped, errors };
+  }
+  for (const suffix of ["", "-opencode"]) {
+    const linkName = `${name}${suffix}`;
+    const linkPath = path2.join(binDir, linkName);
+    if (existsSync2(linkPath)) {
+      skipped.push(linkName);
+      continue;
+    }
+    try {
+      symlinkSync(target, linkPath);
+      created.push(linkName);
+    } catch (err) {
+      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { created, skipped, errors };
+}
+export {
+  EMPLOYEES_PATH,
+  addEmployee,
+  getEmployee,
+  loadEmployees,
+  registerBinSymlinks,
+  saveEmployees,
+  validateEmployeeName
+};

package/dist/lib/error-detector.js

@@ -0,0 +1,156 @@
+// src/lib/error-detector.ts
+import crypto from "crypto";
+
+// src/lib/mcp-prefix.ts
+var MCP_PRIMARY_KEY = "exe-os";
+var MCP_LEGACY_KEY = "exe-mem";
+var MCP_TOOL_PREFIXES = [
+  `mcp__${MCP_PRIMARY_KEY}__`,
+  `mcp__${MCP_LEGACY_KEY}__`
+];
+function isExeMcpTool(toolName) {
+  if (!toolName) return false;
+  return MCP_TOOL_PREFIXES.some((p) => toolName.startsWith(p));
+}
+
+// src/lib/error-detector.ts
+var ERROR_PATTERNS = [
+  /\bError\b/i,
+  /\bERR!\b/,
+  /\bFAIL(ED|URE)?\b/i,
+  /\bException\b/i,
+  /\bTraceback\b/,
+  /\bpanic\b/,
+  /\bSIGSEGV\b/,
+  /\bSIGABRT\b/,
+  /exit code [1-9]/i,
+  /non-zero (exit|status)/i,
+  /command not found/i,
+  /permission denied/i,
+  /ENOENT/,
+  /EACCES/,
+  /ENOMEM/
+];
+var FILE_CONTENT_TOOLS = /* @__PURE__ */ new Set([
+  "Read",
+  "Write",
+  "Edit",
+  "Glob",
+  "Grep",
+  "NotebookEdit"
+]);
+var STDERR_IGNORE_PATTERNS = [
+  /^warning\b/i,
+  /\bDeprecationWarning\b/,
+  /^hint:/i,
+  /^npm warn\b/i,
+  /^npm notice\b/i,
+  /^\(node:\d+\) \w*Warning:/,
+  /^Cloning into/,
+  /^Already on/,
+  /^Switched to/,
+  /^Your branch is/,
+  /^Auto-merging/,
+  /^\s*$/
+];
+function isRealStderr(stderr) {
+  const lines = stderr.trim().split("\n");
+  const meaningful = lines.filter(
+    (line) => line.trim().length > 0 && !STDERR_IGNORE_PATTERNS.some((p) => p.test(line))
+  );
+  return meaningful.length > 0;
+}
+function logSuppression(exitCode, stderr, stdout) {
+  process.stderr.write(
+    `[error-detector] suppressed bash non-zero exit: code=${exitCode} stderr_len=${stderr.length} stdout_len=${stdout.length}
+`
+  );
+}
+function detectError(data) {
+  const response = data.tool_response;
+  if (!response) return false;
+  const toolName = data.tool_name ?? "";
+  if (FILE_CONTENT_TOOLS.has(toolName)) {
+    return response.type === "error" || response.error != null;
+  }
+  if (toolName === "Bash") {
+    const exitCode = typeof response.exitCode === "number" ? response.exitCode : 0;
+    const stderr = typeof response.stderr === "string" ? response.stderr : "";
+    const stdout = typeof response.stdout === "string" ? response.stdout : "";
+    if (exitCode === 141) {
+      logSuppression(exitCode, stderr, stdout);
+      return false;
+    }
+    if (stderr.trim().length > 0 && isRealStderr(stderr)) return true;
+    if (exitCode !== 0 && !isRealStderr(stderr) && stdout.trim().length > 0) {
+      logSuppression(exitCode, stderr, stdout);
+      return false;
+    }
+    if (exitCode !== 0) return true;
+    return false;
+  }
+  if (response.type === "error" || response.error != null || response.isError === true) {
+    return true;
+  }
+  if (typeof response.stderr === "string" && response.stderr.trim().length > 0) {
+    if (isRealStderr(response.stderr)) return true;
+  }
+  const textParts = [];
+  if (typeof response.stdout === "string") textParts.push(response.stdout);
+  if (typeof response.output === "string") textParts.push(response.output);
+  if (typeof response.text === "string") textParts.push(response.text);
+  if (typeof response.message === "string") textParts.push(response.message);
+  if (textParts.length === 0) return false;
+  const text = textParts.join("\n");
+  return ERROR_PATTERNS.some((pattern) => pattern.test(text));
+}
+function isExeOsError(data) {
+  const toolName = data.tool_name ?? "";
+  if (isExeMcpTool(toolName)) return true;
+  if (toolName === "Bash") {
+    const cmd = String(data.tool_input?.command ?? "");
+    if (/\bexe-os\b|exe-boot|exe-healthcheck|scan-tasks|exe-call/.test(cmd)) return true;
+    if (/node.*dist\/(bin|hooks|lib)\//.test(cmd)) return true;
+  }
+  return false;
+}
+var USER_ERROR_PATTERNS = [
+  /not found:?\s/i,
+  /expected \d+ words/i,
+  /provide either/i,
+  /invalid.*parameter/i,
+  /already exists/i,
+  /Multiple tasks match/i,
+  /Use a more specific identifier/i
+];
+var SYSTEM_BUG_PATTERNS = [
+  /SQLITE_ERROR/,
+  /Cannot find module/,
+  /ERR_MODULE_NOT_FOUND/,
+  /TypeError:/,
+  /ReferenceError:/,
+  /Cannot read propert/,
+  /is not a function/,
+  /ENOENT.*dist\//,
+  /dimension mismatch/i,
+  /unhealthy.*model/i,
+  /constraint.*violat/i
+];
+function classifyError(errorText) {
+  if (USER_ERROR_PATTERNS.some((p) => p.test(errorText))) return "user";
+  if (SYSTEM_BUG_PATTERNS.some((p) => p.test(errorText))) return "system";
+  if (/at\s+\S+\s+\(.*exe-os.*\)/m.test(errorText)) return "system";
+  if (/at\s+\S+\s+\(.*dist\/(lib|bin|hooks|mcp)\//m.test(errorText)) return "system";
+  return "unknown";
+}
+function errorFingerprint(toolName, errorText) {
+  const normalized = errorText.replace(/\d{4}-\d{2}-\d{2}T[\d:.]+Z/g, "TIMESTAMP").replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "UUID").replace(/\/Users\/[^\s]+/g, "PATH").replace(/:\d+:\d+/g, ":LINE:COL").slice(0, 200);
+  return crypto.createHash("sha256").update(`${toolName}:${normalized}`).digest("hex").slice(0, 16);
+}
+export {
+  ERROR_PATTERNS,
+  classifyError,
+  detectError,
+  errorFingerprint,
+  isExeOsError
+};