@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-EHOJUXYG.js

@@ -0,0 +1,365 @@
+import {
+  PLATFORM_PROCEDURE_TITLES
+} from "./chunk-6QEFN3DV.js";
+import {
+  getIdentity,
+  listIdentities,
+  updateIdentity
+} from "./chunk-PGW7TIV6.js";
+import {
+  getClient,
+  init_database
+} from "./chunk-A2NZP64U.js";
+
+// src/lib/orchestration-package.ts
+init_database();
+import { randomUUID } from "crypto";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import os from "os";
+import path from "path";
+var PACKAGE_VERSION = "1.0";
+var ROSTER_FILENAME = "exe-employees.json";
+var ROSTER_BACKUP_FILENAME = "exe-employees.json.bak";
+var EXE_OS_DIRNAME = ".exe-os";
+var DEFAULT_BEHAVIOR_PRIORITY = "p1";
+var DEFAULT_PROCEDURE_PRIORITY = "p0";
+var DEFAULT_IDENTITY_UPDATED_BY = "orchestration-import";
+function ensureObject(value, label) {
+  if (value == null || Array.isArray(value) || typeof value !== "object") {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function ensureString(value, label) {
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be a string`);
+  }
+  return value;
+}
+function ensureOptionalString(value, label) {
+  if (value == null) return void 0;
+  return ensureString(value, label);
+}
+function ensureNullableString(value, label) {
+  if (value == null) return null;
+  return ensureString(value, label);
+}
+function ensurePriority(value, label, fallback) {
+  if (value == null) return fallback;
+  if (value === "p0" || value === "p1" || value === "p2") {
+    return value;
+  }
+  throw new Error(`${label} must be one of: p0, p1, p2`);
+}
+function validateRosterEntry(value, index) {
+  const record = ensureObject(value, `roster[${index}]`);
+  return {
+    name: ensureString(record.name, `roster[${index}].name`),
+    role: ensureString(record.role, `roster[${index}].role`),
+    systemPrompt: ensureString(record.systemPrompt, `roster[${index}].systemPrompt`),
+    createdAt: typeof record.createdAt === "string" ? record.createdAt : "",
+    templateName: ensureOptionalString(record.templateName, `roster[${index}].templateName`),
+    templateVersion: typeof record.templateVersion === "number" ? record.templateVersion : void 0
+  };
+}
+function validateBehaviorEntry(value, index) {
+  const record = ensureObject(value, `behaviors[${index}]`);
+  return {
+    agent_id: ensureString(record.agent_id, `behaviors[${index}].agent_id`),
+    project_name: ensureNullableString(record.project_name, `behaviors[${index}].project_name`),
+    domain: ensureNullableString(record.domain, `behaviors[${index}].domain`),
+    content: ensureString(record.content, `behaviors[${index}].content`),
+    priority: ensurePriority(record.priority, `behaviors[${index}].priority`, DEFAULT_BEHAVIOR_PRIORITY)
+  };
+}
+function validateProcedureEntry(value, index) {
+  const record = ensureObject(value, `procedures[${index}]`);
+  return {
+    title: ensureString(record.title, `procedures[${index}].title`),
+    content: ensureString(record.content, `procedures[${index}].content`),
+    priority: ensurePriority(record.priority, `procedures[${index}].priority`, DEFAULT_PROCEDURE_PRIORITY),
+    domain: ensureNullableString(record.domain, `procedures[${index}].domain`)
+  };
+}
+function getRosterPath() {
+  return path.join(os.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
+}
+function getBackupPath() {
+  return path.join(os.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
+}
+function readRosterFile() {
+  const rosterPath = getRosterPath();
+  if (!existsSync(rosterPath)) return [];
+  const raw = readFileSync(rosterPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error("Roster file must contain a JSON array");
+  }
+  return parsed.map((entry, index) => validateRosterEntry(entry, index));
+}
+function writeRosterFile(roster) {
+  if (roster.length === 0) {
+    throw new Error("Refusing to write empty roster \u2014 this would delete all employees");
+  }
+  const rosterPath = getRosterPath();
+  mkdirSync(path.dirname(rosterPath), { recursive: true });
+  if (existsSync(rosterPath)) {
+    const currentRoster = readRosterFile();
+    if (roster.length < currentRoster.length) {
+      throw new Error(
+        `Refusing to write roster with ${roster.length} entries \u2014 current roster has ${currentRoster.length}. Import would delete ${currentRoster.length - roster.length} employee(s). Use merge strategy instead, or add the missing entries to the package.`
+      );
+    }
+    copyFileSync(rosterPath, getBackupPath());
+  }
+  writeFileSync(rosterPath, `${JSON.stringify(roster, null, 2)}
+`, "utf-8");
+}
+function buildImportedRosterEntries(roster, timestamp) {
+  return roster.map((entry) => ({
+    name: entry.name,
+    role: entry.role,
+    systemPrompt: entry.systemPrompt,
+    createdAt: timestamp,
+    ...entry.templateName != null ? { templateName: entry.templateName } : {},
+    ...entry.templateVersion != null ? { templateVersion: entry.templateVersion } : {}
+  }));
+}
+async function insertBehaviors(behaviors, timestamp) {
+  const client = getClient();
+  for (const behavior of behaviors) {
+    await client.execute({
+      sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`,
+      args: [
+        randomUUID(),
+        behavior.agent_id,
+        behavior.project_name,
+        behavior.domain,
+        behavior.priority,
+        behavior.content,
+        timestamp,
+        timestamp
+      ]
+    });
+  }
+  return behaviors.length;
+}
+async function insertProcedures(procedures, timestamp, options) {
+  const client = getClient();
+  const skipTitles = options?.skipTitles ?? /* @__PURE__ */ new Set();
+  let inserted = 0;
+  for (const procedure of procedures) {
+    if (skipTitles.has(procedure.title) || PLATFORM_PROCEDURE_TITLES.has(procedure.title)) {
+      continue;
+    }
+    await client.execute({
+      sql: `INSERT INTO company_procedures (id, title, content, priority, domain, active, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
+      args: [
+        randomUUID(),
+        procedure.title,
+        procedure.content,
+        procedure.priority,
+        procedure.domain,
+        timestamp,
+        timestamp
+      ]
+    });
+    skipTitles.add(procedure.title);
+    inserted += 1;
+  }
+  return inserted;
+}
+async function replaceBehaviorsAndProcedures(behaviors, procedures, timestamp) {
+  const client = getClient();
+  const existingBehaviors = await client.execute({
+    sql: "SELECT agent_id, content FROM behaviors WHERE active = 1",
+    args: []
+  });
+  const existingBehaviorKeys = new Set(
+    existingBehaviors.rows.map((row) => `${String(row.agent_id)}::${String(row.content)}`)
+  );
+  const newBehaviors = behaviors.filter(
+    (b) => !existingBehaviorKeys.has(`${b.agent_id}::${b.content}`)
+  );
+  const existingProcedureTitles = await getActiveProcedureTitles();
+  return {
+    behaviors: await insertBehaviors(newBehaviors, timestamp),
+    procedures: await insertProcedures(procedures, timestamp, { skipTitles: existingProcedureTitles })
+  };
+}
+async function mergeRosterEntries(importedRoster, timestamp) {
+  const currentRoster = readRosterFile();
+  const existingNames = new Set(currentRoster.map((entry) => entry.name.toLowerCase()));
+  const additions = buildImportedRosterEntries(
+    importedRoster.filter((entry) => !existingNames.has(entry.name.toLowerCase())),
+    timestamp
+  );
+  if (additions.length > 0) {
+    writeRosterFile([...currentRoster, ...additions]);
+  }
+  return additions.length;
+}
+async function replaceRosterEntries(importedRoster, timestamp) {
+  const currentRoster = readRosterFile();
+  const importedByName = new Map(
+    buildImportedRosterEntries(importedRoster, timestamp).map((entry) => [entry.name.toLowerCase(), entry])
+  );
+  const merged = currentRoster.map((existing) => {
+    const imported = importedByName.get(existing.name.toLowerCase());
+    if (imported) {
+      importedByName.delete(existing.name.toLowerCase());
+      return imported;
+    }
+    return existing;
+  });
+  for (const newEntry of importedByName.values()) {
+    merged.push(newEntry);
+  }
+  writeRosterFile(merged);
+  return importedRoster.length;
+}
+async function importIdentities(identities, updatedBy) {
+  const entries = Object.entries(identities);
+  let imported = 0;
+  for (const [agentId, content] of entries) {
+    const existing = getIdentity(agentId);
+    if (existing?.raw) {
+      continue;
+    }
+    await updateIdentity(agentId, content, updatedBy);
+    imported += 1;
+  }
+  return imported;
+}
+async function getActiveProcedureTitles() {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT title FROM company_procedures WHERE active = 1",
+    args: []
+  });
+  return new Set(result.rows.map((row) => String(row.title)));
+}
+async function exportOrchestration(createdBy) {
+  const client = getClient();
+  const roster = readRosterFile().map((entry) => ({
+    ...entry,
+    createdAt: ""
+  }));
+  const identities = {};
+  for (const identitySummary of listIdentities()) {
+    const identity = getIdentity(identitySummary.agentId);
+    if (identity?.raw) {
+      identities[identitySummary.agentId] = identity.raw;
+    }
+  }
+  const behaviorResult = await client.execute({
+    sql: "SELECT agent_id, project_name, domain, content, priority FROM behaviors WHERE active = 1",
+    args: []
+  });
+  const procedureResult = await client.execute({
+    sql: "SELECT title, content, priority, domain FROM company_procedures WHERE active = 1",
+    args: []
+  });
+  const behaviors = behaviorResult.rows.map((row) => ({
+    agent_id: String(row.agent_id),
+    project_name: row.project_name == null ? null : String(row.project_name),
+    domain: row.domain == null ? null : String(row.domain),
+    content: String(row.content),
+    priority: ensurePriority(row.priority, "behaviors.priority", DEFAULT_BEHAVIOR_PRIORITY)
+  }));
+  const procedures = procedureResult.rows.map((row) => ({
+    title: String(row.title),
+    content: String(row.content),
+    priority: ensurePriority(row.priority, "procedures.priority", DEFAULT_PROCEDURE_PRIORITY),
+    domain: row.domain == null ? null : String(row.domain)
+  })).filter((procedure) => !PLATFORM_PROCEDURE_TITLES.has(procedure.title));
+  return {
+    version: PACKAGE_VERSION,
+    created_by: createdBy,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    roster,
+    identities,
+    behaviors,
+    procedures
+  };
+}
+async function importOrchestration(pkg, strategy) {
+  const validated = validatePackage(pkg);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedBy = validated.created_by || DEFAULT_IDENTITY_UPDATED_BY;
+  const rosterCount = strategy === "replace" ? await replaceRosterEntries(validated.roster, timestamp) : await mergeRosterEntries(validated.roster, timestamp);
+  const identityCount = await importIdentities(validated.identities, updatedBy);
+  if (strategy === "replace") {
+    const replaced = await replaceBehaviorsAndProcedures(
+      validated.behaviors,
+      validated.procedures,
+      timestamp
+    );
+    return {
+      imported: {
+        roster: rosterCount,
+        identities: identityCount,
+        behaviors: replaced.behaviors,
+        procedures: replaced.procedures
+      }
+    };
+  }
+  const existingProcedureTitles = await getActiveProcedureTitles();
+  const behaviorCount = await insertBehaviors(validated.behaviors, timestamp);
+  const procedureCount = await insertProcedures(
+    validated.procedures,
+    timestamp,
+    { skipTitles: existingProcedureTitles }
+  );
+  return {
+    imported: {
+      roster: rosterCount,
+      identities: identityCount,
+      behaviors: behaviorCount,
+      procedures: procedureCount
+    }
+  };
+}
+function validatePackage(data) {
+  const record = ensureObject(data, "package");
+  const version = ensureString(record.version, "version");
+  if (version !== PACKAGE_VERSION) {
+    throw new Error(`Unsupported orchestration package version: ${version}`);
+  }
+  if (!Array.isArray(record.roster)) {
+    throw new Error("roster is required and must be an array");
+  }
+  if (record.identities == null || Array.isArray(record.identities) || typeof record.identities !== "object") {
+    throw new Error("identities is required and must be an object");
+  }
+  if (!Array.isArray(record.behaviors)) {
+    throw new Error("behaviors is required and must be an array");
+  }
+  if (!Array.isArray(record.procedures)) {
+    throw new Error("procedures is required and must be an array");
+  }
+  const identities = Object.entries(record.identities).reduce(
+    (acc, [agentId, content]) => {
+      acc[agentId] = ensureString(content, `identities.${agentId}`);
+      return acc;
+    },
+    {}
+  );
+  return {
+    version: PACKAGE_VERSION,
+    created_by: ensureString(record.created_by, "created_by"),
+    created_at: ensureString(record.created_at, "created_at"),
+    roster: record.roster.map((entry, index) => validateRosterEntry(entry, index)),
+    identities,
+    behaviors: record.behaviors.map((entry, index) => validateBehaviorEntry(entry, index)),
+    procedures: record.procedures.map((entry, index) => validateProcedureEntry(entry, index))
+  };
+}
+
+export {
+  exportOrchestration,
+  importOrchestration,
+  validatePackage
+};

package/dist/chunk-EIT6J37V.js

@@ -0,0 +1,119 @@
+// src/runtime/tools/grep.ts
+import { spawn } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var inputSchema = z.object({
+  pattern: z.string(),
+  path: z.string().optional(),
+  glob: z.string().optional(),
+  include: z.string().optional()
+});
+var GrepTool = {
+  name: "grep",
+  description: "Search file contents using regex",
+  inputSchema,
+  isReadOnly: true,
+  async call(input, context) {
+    const searchPath = input.path ? path.isAbsolute(input.path) ? input.path : path.resolve(context.cwd, input.path) : context.cwd;
+    try {
+      const result = await runRipgrep(input, searchPath, context);
+      return result;
+    } catch {
+    }
+    try {
+      return await nodeGrep(input, searchPath);
+    } catch (err) {
+      return {
+        content: `Grep error: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+function runRipgrep(input, searchPath, context) {
+  return new Promise((resolve, reject) => {
+    const args = ["--files-with-matches", "--no-heading"];
+    if (input.glob) {
+      args.push("--glob", input.glob);
+    }
+    if (input.include) {
+      args.push("--glob", input.include);
+    }
+    args.push(input.pattern, searchPath);
+    const child = spawn("rg", args, {
+      cwd: searchPath,
+      timeout: 3e4,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const MAX_OUTPUT = 1e7;
+    const chunks = [];
+    let totalSize = 0;
+    child.stdout.on("data", (chunk) => {
+      totalSize += chunk.length;
+      if (totalSize <= MAX_OUTPUT) chunks.push(chunk);
+    });
+    const onAbort = () => child.kill("SIGTERM");
+    context.abortSignal.addEventListener("abort", onAbort, { once: true });
+    child.on("close", (code) => {
+      context.abortSignal.removeEventListener("abort", onAbort);
+      const output = Buffer.concat(chunks).toString("utf-8").trim();
+      if (code === 1 && !output) {
+        resolve({ content: "No matches found." });
+        return;
+      }
+      if (code === 2) {
+        reject(new Error("ripgrep error"));
+        return;
+      }
+      resolve({ content: output || "No matches found." });
+    });
+    child.on("error", () => reject(new Error("rg not found")));
+  });
+}
+async function nodeGrep(input, searchPath) {
+  const regex = new RegExp(input.pattern);
+  const matches = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === ".git") continue;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else {
+        if (input.glob || input.include) {
+          const filter = input.glob ?? input.include;
+          if (!simpleExtMatch(entry.name, filter)) continue;
+        }
+        try {
+          const content = await fs.readFile(fullPath, "utf-8");
+          if (regex.test(content)) {
+            matches.push(fullPath);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  await walk(searchPath);
+  if (matches.length === 0) {
+    return { content: "No matches found." };
+  }
+  return { content: matches.join("\n") };
+}
+function simpleExtMatch(filename, pattern) {
+  if (pattern.startsWith("*.")) {
+    return filename.endsWith(pattern.slice(1));
+  }
+  return filename.includes(pattern.replace(/\*/g, ""));
+}
+
+export {
+  GrepTool
+};

package/dist/chunk-ELE2C7L4.js

@@ -0,0 +1,31 @@
+import {
+  __esm,
+  __export
+} from "./chunk-KFQGP6VL.js";
+
+// src/lib/agent-context.ts
+var agent_context_exports = {};
+__export(agent_context_exports, {
+  getAgentContext: () => getAgentContext,
+  runWithAgent: () => runWithAgent
+});
+import { AsyncLocalStorage } from "async_hooks";
+function runWithAgent(ctx, fn) {
+  return agentStore.run(ctx, fn);
+}
+function getAgentContext() {
+  return agentStore.getStore();
+}
+var agentStore;
+var init_agent_context = __esm({
+  "src/lib/agent-context.ts"() {
+    agentStore = new AsyncLocalStorage();
+  }
+});
+
+export {
+  runWithAgent,
+  getAgentContext,
+  agent_context_exports,
+  init_agent_context
+};

package/dist/chunk-EQSQ4HBW.js

@@ -0,0 +1,9 @@
+// src/lib/pg-ssl.ts
+function pgSslConfig() {
+  if (process.env.EXE_DB_SSL_DISABLED === "true") return {};
+  return { ssl: { rejectUnauthorized: process.env.EXE_DB_SSL_ALLOW_SELFSIGNED !== "true" } };
+}
+
+export {
+  pgSslConfig
+};

package/dist/chunk-FWFFZGSC.js

@@ -0,0 +1,94 @@
+// src/lib/providers/ollama.ts
+import { randomUUID } from "crypto";
+var OllamaProvider = class {
+  name;
+  defaultModel;
+  host;
+  constructor(name, config = {}) {
+    this.name = name;
+    this.host = (config.host ?? "http://localhost:11434").replace(/\/+$/, "");
+    this.defaultModel = config.defaultModel ?? "qwen3:14b";
+  }
+  async createMessage(params) {
+    const messages = [
+      { role: "system", content: params.system }
+    ];
+    for (const msg of params.messages) {
+      if (typeof msg.content === "string") {
+        messages.push({ role: msg.role, content: msg.content });
+      } else {
+        const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+        messages.push({ role: msg.role, content: text });
+      }
+    }
+    const tools = params.tools?.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.inputSchema
+      }
+    }));
+    const body = {
+      model: params.model || this.defaultModel,
+      messages,
+      stream: false,
+      options: { num_predict: params.maxTokens }
+    };
+    if (tools?.length) body.tools = tools;
+    const res = await fetch(`${this.host}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!res.ok) {
+      throw new Error(`Ollama API error: ${res.status} ${await res.text()}`);
+    }
+    const data = await res.json();
+    return this.normalizeResponse(data);
+  }
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      const res = await fetch(`${this.host}/api/tags`, {
+        signal: AbortSignal.timeout(5e3)
+      });
+      return { available: res.ok, latencyMs: Date.now() - start };
+    } catch {
+      return { available: false };
+    }
+  }
+  normalizeResponse(data) {
+    const content = [];
+    if (data.message.content) {
+      content.push({ type: "text", text: data.message.content });
+    }
+    if (data.message.tool_calls) {
+      for (const call of data.message.tool_calls) {
+        content.push({
+          type: "tool_use",
+          id: randomUUID(),
+          name: call.function.name,
+          input: call.function.arguments
+        });
+      }
+    }
+    if (content.length === 0) {
+      content.push({ type: "text", text: "" });
+    }
+    const hasToolUse = content.some((b) => b.type === "tool_use");
+    return {
+      content,
+      stopReason: hasToolUse ? "tool_use" : "end_turn",
+      usage: {
+        inputTokens: data.prompt_eval_count ?? 0,
+        outputTokens: data.eval_count ?? 0
+      }
+    };
+  }
+};
+
+export {
+  OllamaProvider
+};