@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-O377P7GM.js

@@ -0,0 +1,100 @@
+// src/runtime/hooks.ts
+function createDefaultHooks() {
+  return {};
+}
+function composeHooks(...pipelines) {
+  return {
+    async onSessionStart(context) {
+      for (const p of pipelines) {
+        if (p.onSessionStart) await p.onSessionStart(context);
+      }
+    },
+    async onSessionEnd(context, summary) {
+      for (const p of pipelines) {
+        if (p.onSessionEnd) await p.onSessionEnd(context, summary);
+      }
+    },
+    async beforeToolUse(block, context) {
+      for (const p of pipelines) {
+        if (p.beforeToolUse) {
+          const result = await p.beforeToolUse(block, context);
+          if (result) return result;
+        }
+      }
+      return null;
+    },
+    async afterToolUse(block, result, context) {
+      for (const p of pipelines) {
+        if (p.afterToolUse) await p.afterToolUse(block, result, context);
+      }
+    },
+    async onError(error, context) {
+      for (const p of pipelines) {
+        if (p.onError) await p.onError(error, context);
+      }
+    },
+    async onCompact(removedMessages, summaryLength) {
+      for (const p of pipelines) {
+        if (p.onCompact) await p.onCompact(removedMessages, summaryLength);
+      }
+    },
+    async onPostCompact(removedMessages, injectedSummary) {
+      for (const p of pipelines) {
+        if (p.onPostCompact) await p.onPostCompact(removedMessages, injectedSummary);
+      }
+    },
+    async onSubagentStop(reason) {
+      for (const p of pipelines) {
+        if (p.onSubagentStop) {
+          const result = await p.onSubagentStop(reason);
+          if (result.block) return result;
+        }
+      }
+      return { block: false };
+    },
+    async onNotification(message) {
+      for (const p of pipelines) {
+        if (p.onNotification) await p.onNotification(message);
+      }
+    },
+    async onPermissionRequest(toolName, reason) {
+      for (const p of pipelines) {
+        if (p.onPermissionRequest) {
+          const result = await p.onPermissionRequest(toolName, reason);
+          if (result.autoApprove) return result;
+        }
+      }
+      return { autoApprove: false };
+    },
+    async onTaskAssigned(event) {
+      for (const p of pipelines) {
+        if (p.onTaskAssigned) await p.onTaskAssigned(event);
+      }
+    },
+    async onReviewReceived(event) {
+      for (const p of pipelines) {
+        if (p.onReviewReceived) await p.onReviewReceived(event);
+      }
+    },
+    async onContextPressure(event) {
+      for (const p of pipelines) {
+        if (p.onContextPressure) await p.onContextPressure(event);
+      }
+    },
+    async onCrossAgentMessage(event) {
+      for (const p of pipelines) {
+        if (p.onCrossAgentMessage) await p.onCrossAgentMessage(event);
+      }
+    },
+    async onTokenBudgetExceeded(ctx, fallback) {
+      for (const p of pipelines) {
+        if (p.onTokenBudgetExceeded) await p.onTokenBudgetExceeded(ctx, fallback);
+      }
+    }
+  };
+}
+
+export {
+  createDefaultHooks,
+  composeHooks
+};

package/dist/chunk-O4VFZRA5.js

@@ -0,0 +1,33 @@
+import {
+  completeReminder
+} from "./chunk-4Y6QZBEO.js";
+
+// src/mcp/tools/complete-reminder.ts
+import { z } from "zod";
+function registerCompleteReminder(server) {
+  server.registerTool(
+    "complete_reminder",
+    {
+      title: "Complete Reminder",
+      description: "Mark a reminder as done. Accepts UUID or text substring.",
+      inputSchema: {
+        reminder_id: z.string().describe("Reminder UUID or text substring to match")
+      }
+    },
+    async ({ reminder_id }) => {
+      const reminder = await completeReminder(reminder_id);
+      if (!reminder) {
+        return {
+          content: [{ type: "text", text: `No active reminder matching "${reminder_id}".` }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Reminder completed: "${reminder.text}"` }]
+      };
+    }
+  );
+}
+
+export {
+  registerCompleteReminder
+};

package/dist/chunk-O7YD7JYE.js

@@ -0,0 +1,237 @@
+// src/lib/code-chunker.ts
+import ts from "typescript";
+var LANGUAGE_BY_EXTENSION = {
+  c: "c",
+  cc: "cpp",
+  cpp: "cpp",
+  cxx: "cpp",
+  h: "c",
+  hh: "cpp",
+  hpp: "cpp",
+  cs: "csharp",
+  css: "css",
+  scss: "scss",
+  f: "fortran",
+  f90: "fortran",
+  f95: "fortran",
+  go: "go",
+  html: "html",
+  htm: "html",
+  java: "java",
+  js: "javascript",
+  jsx: "javascript",
+  json: "json",
+  kt: "kotlin",
+  kts: "kotlin",
+  lua: "lua",
+  md: "markdown",
+  mdx: "mdx",
+  pas: "pascal",
+  php: "php",
+  py: "python",
+  r: "r",
+  rb: "ruby",
+  rs: "rust",
+  scala: "scala",
+  sc: "scala",
+  sol: "solidity",
+  sql: "sql",
+  svelte: "svelte",
+  swift: "swift",
+  toml: "toml",
+  ts: "typescript",
+  tsx: "typescript",
+  vue: "vue",
+  xml: "xml",
+  yaml: "yaml",
+  yml: "yaml",
+  sh: "shell",
+  bash: "shell",
+  zsh: "shell"
+};
+var TEXT_LIKE_LANGUAGES = /* @__PURE__ */ new Set(["json", "markdown", "mdx", "toml", "yaml", "xml", "html", "css", "scss", "sql"]);
+function languageForFile(filePath) {
+  const base = filePath.split(/[\\/]/).pop()?.toLowerCase() ?? "";
+  if (["dockerfile", "makefile", "rakefile", "gemfile"].includes(base)) return base;
+  const ext = base.includes(".") ? base.split(".").pop() : void 0;
+  return ext ? LANGUAGE_BY_EXTENSION[ext] : void 0;
+}
+function chunkSourceFile(source, fileName = "file.ts") {
+  const language = languageForFile(fileName);
+  if (language === "typescript" || language === "javascript") {
+    return chunkTypeScriptLike(source, fileName);
+  }
+  return chunkGenericSource(source, fileName, language);
+}
+function chunkTypeScriptLike(source, fileName) {
+  const sourceFile = ts.createSourceFile(
+    fileName,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    fileName.endsWith(".tsx") || fileName.endsWith(".jsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+  const chunks = [];
+  const lines = source.split("\n");
+  const importLines = [];
+  function getLineNumber(pos) {
+    return sourceFile.getLineAndCharacterOfPosition(pos).line + 1;
+  }
+  function getLeadingComment(node) {
+    const fullText = sourceFile.getFullText();
+    const ranges = ts.getLeadingCommentRanges(fullText, node.getFullStart());
+    if (!ranges || ranges.length === 0) return void 0;
+    return ranges.map((r) => fullText.slice(r.pos, r.end)).join("\n");
+  }
+  function getNodeText(node) {
+    return node.getText(sourceFile);
+  }
+  function getName(node) {
+    if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+      return node.name?.getText(sourceFile) ?? "(anonymous)";
+    }
+    if (ts.isClassDeclaration(node)) return node.name?.getText(sourceFile) ?? "(anonymous class)";
+    if (ts.isInterfaceDeclaration(node)) return node.name.getText(sourceFile);
+    if (ts.isTypeAliasDeclaration(node)) return node.name.getText(sourceFile);
+    if (ts.isEnumDeclaration(node)) return node.name.getText(sourceFile);
+    if (ts.isVariableStatement(node)) return node.declarationList.declarations.map((d) => d.name.getText(sourceFile)).join(", ");
+    if (ts.isExportAssignment(node)) return "default export";
+    return "(unknown)";
+  }
+  function visitTopLevel(node) {
+    if (ts.isImportDeclaration(node)) {
+      importLines.push({ start: getLineNumber(node.getStart(sourceFile)), end: getLineNumber(node.getEnd()) });
+      return;
+    }
+    if (ts.isFunctionDeclaration(node)) {
+      chunks.push({ kind: "function", name: getName(node), text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
+      return;
+    }
+    if (ts.isClassDeclaration(node)) {
+      chunks.push({ kind: "class", name: getName(node), text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
+      return;
+    }
+    if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node)) {
+      chunks.push({ kind: "type", name: getName(node), text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
+      return;
+    }
+    if (ts.isVariableStatement(node)) {
+      const isFnLike = node.declarationList.declarations.some((d) => d.initializer && (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer)));
+      chunks.push({ kind: isFnLike ? "function" : "variable", name: getName(node), text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
+      return;
+    }
+    if (ts.isExportAssignment(node)) {
+      chunks.push({ kind: "export", name: "default export", text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
+      return;
+    }
+    if (ts.isExpressionStatement(node)) {
+      const text = getNodeText(node);
+      if (text.length > 10) chunks.push({ kind: "other", name: text.slice(0, 40).replace(/\n/g, " "), text, startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()) });
+    }
+  }
+  sourceFile.statements.forEach(visitTopLevel);
+  if (importLines.length > 0) {
+    const startLine = importLines[0].start;
+    const endLine = importLines[importLines.length - 1].end;
+    chunks.unshift({ kind: "import", name: `${importLines.length} imports`, text: lines.slice(startLine - 1, endLine).join("\n"), startLine, endLine });
+  }
+  chunks.sort((a, b) => a.startLine - b.startLine);
+  return chunks.length > 0 ? chunks : chunkByWindows(source, 80);
+}
+function chunkGenericSource(source, _fileName, language) {
+  const lines = source.split("\n");
+  if (source.trim().length === 0) return [];
+  if (language && TEXT_LIKE_LANGUAGES.has(language)) return chunkTextLike(lines, language);
+  const chunks = [];
+  const patterns = [
+    { kind: "function", regex: /^\s*(?:async\s+)?def\s+([A-Za-z_][\w]*)\s*\(/, name: (m) => m[1] },
+    { kind: "class", regex: /^\s*class\s+([A-Za-z_][\w]*)\b/, name: (m) => m[1] },
+    { kind: "function", regex: /^\s*(?:pub\s+)?fn\s+([A-Za-z_][\w]*)\s*[<(]/, name: (m) => m[1] },
+    { kind: "class", regex: /^\s*(?:pub\s+)?(?:struct|enum|trait)\s+([A-Za-z_][\w]*)\b/, name: (m) => m[1] },
+    { kind: "function", regex: /^\s*func\s+(?:\([^)]*\)\s*)?([A-Za-z_][\w]*)\s*\(/, name: (m) => m[1] },
+    { kind: "function", regex: /^\s*(?:public|private|protected|static|final|suspend|fun|override|open|internal|export|async|func|function|subroutine)\s+.*?([A-Za-z_][\w]*)\s*\(/, name: (m) => m[1] },
+    { kind: "function", regex: /^\s*function\s+([A-Za-z_][\w]*)\s*\(/, name: (m) => m[1] },
+    { kind: "type", regex: /^\s*(?:interface|type|enum|record|data\s+class|case\s+class|contract|library)\s+([A-Za-z_][\w]*)\b/, name: (m) => m[1] },
+    { kind: "section", regex: /^\s{0,3}#{1,6}\s+(.+)$/, name: (m) => m[1].trim() }
+  ];
+  const starts = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const pattern of patterns) {
+      const match = line.match(pattern.regex);
+      if (match) {
+        starts.push({ line: i + 1, kind: pattern.kind, name: pattern.name(match) });
+        break;
+      }
+    }
+  }
+  if (starts.length === 0) return chunkByWindows(source, 80);
+  for (let i = 0; i < starts.length; i++) {
+    const start = starts[i];
+    const next = starts[i + 1]?.line ?? lines.length + 1;
+    const endLine = Math.max(start.line, next - 1);
+    chunks.push({
+      kind: start.kind,
+      name: start.name,
+      text: lines.slice(start.line - 1, endLine).join("\n"),
+      startLine: start.line,
+      endLine
+    });
+  }
+  return chunks;
+}
+function chunkTextLike(lines, language) {
+  if (language === "markdown" || language === "mdx") {
+    const starts = lines.map((line, i) => ({ line, i })).filter(({ line }) => /^\s{0,3}#{1,6}\s+/.test(line));
+    if (starts.length > 0) {
+      return starts.map((start, idx) => {
+        const end = starts[idx + 1]?.i ?? lines.length;
+        const title = start.line.replace(/^\s{0,3}#{1,6}\s+/, "").trim();
+        return { kind: "section", name: title, text: lines.slice(start.i, end).join("\n"), startLine: start.i + 1, endLine: end };
+      });
+    }
+  }
+  return chunkByWindows(lines.join("\n"), 80);
+}
+function chunkByWindows(source, windowLines) {
+  const lines = source.split("\n");
+  const chunks = [];
+  for (let i = 0; i < lines.length; i += windowLines) {
+    const end = Math.min(lines.length, i + windowLines);
+    const text = lines.slice(i, end).join("\n");
+    if (text.trim()) chunks.push({ kind: "other", name: `lines ${i + 1}-${end}`, text, startLine: i + 1, endLine: end });
+  }
+  return chunks;
+}
+function summarizeChunk(chunk, filePath) {
+  const location = `${filePath}:${chunk.startLine}-${chunk.endLine}`;
+  const comment = chunk.comment ? chunk.comment.replace(/\/\*\*|\*\/|\*\s?/g, "").trim().split("\n")[0] : "";
+  switch (chunk.kind) {
+    case "function":
+      return `Function ${chunk.name} in ${location}${comment ? ` \u2014 ${comment}` : ""}`;
+    case "class":
+      return `Class ${chunk.name} in ${location}${comment ? ` \u2014 ${comment}` : ""}`;
+    case "type":
+      return `Type ${chunk.name} in ${location}`;
+    case "import":
+      return `Imports (${chunk.name}) in ${filePath}`;
+    case "variable":
+      return `Variable ${chunk.name} in ${location}`;
+    case "export":
+      return `Default export in ${location}`;
+    case "section":
+      return `Section ${chunk.name} in ${location}`;
+    default:
+      return `${chunk.kind} in ${location}`;
+  }
+}
+function isChunkable(filePath) {
+  return Boolean(languageForFile(filePath));
+}
+
+export {
+  languageForFile,
+  chunkSourceFile,
+  summarizeChunk,
+  isChunkable
+};

package/dist/chunk-OFK72LTZ.js

@@ -0,0 +1,81 @@
+import {
+  init_employees,
+  loadEmployees
+} from "./chunk-RUG3N6P4.js";
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/lib/agent-symlinks.ts
+import os from "os";
+import path from "path";
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readlinkSync,
+  symlinkSync
+} from "fs";
+function claudeAgentsDir(homeDir) {
+  return path.join(homeDir, ".claude", "agents");
+}
+function identitySourcePath(homeDir, agentId) {
+  return path.join(homeDir, ".exe-os", "identity", `${agentId}.md`);
+}
+function claudeAgentLinkPath(homeDir, agentId) {
+  return path.join(claudeAgentsDir(homeDir), `${agentId}.md`);
+}
+function ensureAgentSymlink(agentId, homeDir = os.homedir()) {
+  const target = identitySourcePath(homeDir, agentId);
+  const link = claudeAgentLinkPath(homeDir, agentId);
+  mkdirSync(claudeAgentsDir(homeDir), { recursive: true });
+  if (existsSync(link)) {
+    let stat;
+    try {
+      stat = lstatSync(link);
+    } catch {
+      return { agentId, action: "conflict", target, link, conflict: "stat_failed" };
+    }
+    if (!stat.isSymbolicLink()) {
+      return { agentId, action: "conflict", target, link, conflict: "regular_file" };
+    }
+    let currentTarget;
+    try {
+      currentTarget = readlinkSync(link);
+    } catch {
+      return { agentId, action: "conflict", target, link, conflict: "readlink_failed" };
+    }
+    if (currentTarget === target) {
+      return { agentId, action: "already_correct", target, link };
+    }
+    return { agentId, action: "conflict", target, link, conflict: `points_to:${currentTarget}` };
+  }
+  try {
+    symlinkSync(target, link);
+  } catch (err) {
+    return {
+      agentId,
+      action: "conflict",
+      target,
+      link,
+      conflict: err instanceof Error ? err.message : String(err)
+    };
+  }
+  return { agentId, action: "created", target, link };
+}
+async function ensureAllAgentSymlinks(homeDir = os.homedir()) {
+  const employees = await loadEmployees();
+  return employees.map((emp) => ensureAgentSymlink(emp.name, homeDir));
+}
+var init_agent_symlinks = __esm({
+  "src/lib/agent-symlinks.ts"() {
+    "use strict";
+    init_employees();
+  }
+});
+
+export {
+  ensureAgentSymlink,
+  ensureAllAgentSymlinks,
+  init_agent_symlinks
+};

package/dist/chunk-ORCCI2VV.js

@@ -0,0 +1,140 @@
+// src/gateway/adapters/slack.ts
+import { randomUUID } from "crypto";
+var SlackAdapter = class {
+  platform = "slack";
+  webClient = null;
+  // WebClient — dynamic import
+  socketClient = null;
+  // SocketModeClient — dynamic import
+  messageHandler = null;
+  connected = false;
+  botUserId = "";
+  async connect(config) {
+    const { WebClient } = await import("@slack/web-api");
+    const { SocketModeClient } = await import("@slack/socket-mode");
+    const token = config.credentials.bot_token ?? config.credentials.token;
+    const appToken = config.credentials.app_token;
+    if (!token) {
+      throw new Error("Slack requires bot_token (xoxb-) in credentials");
+    }
+    if (!appToken) {
+      throw new Error("Slack requires app_token (xapp-) for Socket Mode in credentials");
+    }
+    this.webClient = new WebClient(token);
+    this.socketClient = new SocketModeClient({ appToken });
+    try {
+      const auth = await this.webClient.auth.test();
+      this.botUserId = auth.user_id ?? "";
+    } catch (err) {
+      throw new Error(
+        `Slack auth failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    this.socketClient.on("message", async ({ event, ack }) => {
+      await ack();
+      if (!this.messageHandler || !event) return;
+      if (event.user === this.botUserId) return;
+      if (event.subtype) return;
+      const isGroup = event.channel_type !== "im";
+      const normalized = {
+        messageId: event.client_msg_id ?? event.ts ?? randomUUID(),
+        platform: "slack",
+        senderId: event.user ?? "",
+        channelId: event.channel ?? "",
+        chatType: isGroup ? "group" : "direct",
+        text: event.text ?? "",
+        timestamp: event.ts ? new Date(parseFloat(event.ts) * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+        threadId: event.thread_ts ?? void 0,
+        replyTo: event.thread_ts && event.thread_ts !== event.ts ? {
+          messageId: event.thread_ts,
+          text: "",
+          senderId: ""
+        } : void 0,
+        media: this.extractMedia(event),
+        raw: event
+      };
+      try {
+        await this.messageHandler(normalized);
+      } catch (err) {
+        console.error("[slack] Message handler error:", err);
+      }
+    });
+    await this.socketClient.start();
+    this.connected = true;
+    console.log("[slack] Connected via Socket Mode");
+  }
+  async disconnect() {
+    await this.socketClient?.disconnect();
+    this.socketClient = null;
+    this.webClient = null;
+    this.connected = false;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async sendText(channelId, text, options) {
+    if (!this.webClient || !this.connected) throw new Error("Slack not connected");
+    await this.webClient.chat.postMessage({
+      channel: channelId,
+      text,
+      thread_ts: options?.replyToMessageId
+    });
+  }
+  async sendTyping(_channelId) {
+  }
+  async healthCheck() {
+    if (!this.webClient) return { connected: false };
+    const start = Date.now();
+    try {
+      await this.webClient.auth.test();
+      return { connected: true, latencyMs: Date.now() - start };
+    } catch {
+      return { connected: false };
+    }
+  }
+  /** Inject a raw Slack event payload from webhook server */
+  async injectMessage(rawPayload) {
+    if (!this.messageHandler) return;
+    const event = rawPayload;
+    if (!event.text) return;
+    const isGroup = event.channel_type !== "im";
+    const normalized = {
+      messageId: event.ts ?? randomUUID(),
+      platform: "slack",
+      senderId: event.user ?? "",
+      senderName: event.user_profile?.display_name ?? event.user_profile?.real_name ?? void 0,
+      channelId: event.channel ?? "",
+      chatType: isGroup ? "group" : "direct",
+      text: event.text,
+      timestamp: event.ts ? new Date(parseFloat(event.ts) * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+      threadId: event.thread_ts ?? void 0,
+      media: this.extractMedia(event),
+      raw: rawPayload
+    };
+    try {
+      await this.messageHandler(normalized);
+    } catch (err) {
+      console.error("[slack] injectMessage handler error:", err);
+    }
+  }
+  extractMedia(event) {
+    const files = event.files;
+    if (!files || !Array.isArray(files) || files.length === 0) return void 0;
+    return files.map((f) => {
+      const mimetype = f.mimetype ?? "";
+      let type = "document";
+      if (mimetype.startsWith("image/")) type = "image";
+      else if (mimetype.startsWith("video/")) type = "video";
+      else if (mimetype.startsWith("audio/")) type = "audio";
+      return {
+        type,
+        url: f.url_private ?? void 0,
+        fileName: f.name ?? void 0
+      };
+    });
+  }
+};
+
+export {
+  SlackAdapter
+};