@askexenow/exe-os 0.9.288 → 0.9.290

package/dist/chunk-FTG36JG5.js

@@ -0,0 +1,280 @@
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-CMDKYYFK.js";
+
+// src/lib/worktree.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync, appendFileSync, mkdirSync, realpathSync } from "fs";
+import path from "path";
+var GIT_TIMEOUT_MS = 1e4;
+function getGitRoot(dir) {
+  try {
+    const root = execSync("git rev-parse --show-toplevel", {
+      cwd: dir,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return realpath(root);
+  } catch {
+    return null;
+  }
+}
+function getMainRepoRoot(dir) {
+  try {
+    const commonDir = execSync(
+      "git rev-parse --path-format=absolute --git-common-dir",
+      { cwd: dir, encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    return realpath(path.dirname(commonDir));
+  } catch {
+    return null;
+  }
+}
+function worktreePath(repoRoot, employeeName, instance) {
+  const label = instanceLabel(employeeName, instance);
+  return path.join(repoRoot, ".worktrees", label);
+}
+function worktreeBranch(employeeName, instance, taskSlug) {
+  const label = instanceLabel(employeeName, instance);
+  if (taskSlug) {
+    const slug = taskSlug.slice(0, 40).replace(/[^a-z0-9-]/gi, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+    return `${label}-${slug}`;
+  }
+  return `${label}-work`;
+}
+function instanceLabel(name, instance) {
+  return instance != null && instance > 0 ? `${name}${instance}` : name;
+}
+function ensureWorktree(projectDir, employeeName, instance) {
+  const repoRoot = getGitRoot(projectDir);
+  if (!repoRoot) return null;
+  const wtPath = worktreePath(repoRoot, employeeName, instance);
+  const branch = worktreeBranch(employeeName, instance);
+  if (existsSync(path.join(wtPath, ".git"))) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.reused",
+      source: "worktree.ensureWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch }
+    });
+    return wtPath;
+  }
+  const worktreesDir = path.join(repoRoot, ".worktrees");
+  mkdirSync(worktreesDir, { recursive: true });
+  ensureGitignoreEntry(repoRoot, "/.worktrees/");
+  try {
+    execSync("git worktree prune", {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+  const branchExists = branchExistsLocally(repoRoot, branch);
+  try {
+    if (branchExists) {
+      execSync(`git worktree add "${wtPath}" "${branch}"`, {
+        cwd: repoRoot,
+        encoding: "utf-8",
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } else {
+      execSync(`git worktree add "${wtPath}" -b "${branch}" HEAD`, {
+        cwd: repoRoot,
+        encoding: "utf-8",
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.created",
+      source: "worktree.ensureWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch, reusedBranch: branchExists }
+    });
+    return wtPath;
+  } catch (err) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.failed",
+      source: "worktree.ensureWorktree",
+      severity: "warn",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      errorCode: err instanceof Error ? err.name : "worktree_create_failed",
+      payload: { branch }
+    });
+    process.stderr.write(
+      `[worktree] Failed to create worktree for ${employeeName}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+function isWorktreeDirty(wtPath) {
+  try {
+    const status = execSync("git status --porcelain", {
+      cwd: wtPath,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return status.length > 0;
+  } catch {
+    return true;
+  }
+}
+function cleanupWorktree(projectDir, employeeName, instance) {
+  const repoRoot = getMainRepoRoot(projectDir);
+  if (!repoRoot) return { cleaned: false, reason: "not a git repo" };
+  const wtPath = worktreePath(repoRoot, employeeName, instance);
+  const branch = worktreeBranch(employeeName, instance);
+  if (!existsSync(wtPath)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "worktree does not exist", branch }
+    });
+    return { cleaned: false, reason: "worktree does not exist" };
+  }
+  if (isWorktreeDirty(wtPath)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "worktree has uncommitted changes", branch }
+    });
+    return { cleaned: false, reason: "worktree has uncommitted changes" };
+  }
+  const mainBranch = detectMainBranch(repoRoot);
+  if (!mainBranch) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "could not determine main branch", branch }
+    });
+    return { cleaned: false, reason: "could not determine main branch" };
+  }
+  if (!isBranchMerged(repoRoot, branch, mainBranch)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "branch not merged", branch, mainBranch }
+    });
+    return { cleaned: false, reason: `branch ${branch} not merged into ${mainBranch}` };
+  }
+  try {
+    execSync(`git worktree remove "${wtPath}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (err) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.failed",
+      source: "worktree.cleanupWorktree",
+      severity: "warn",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      errorCode: err instanceof Error ? err.name : "worktree_remove_failed",
+      payload: { branch, mainBranch }
+    });
+    return {
+      cleaned: false,
+      reason: `git worktree remove failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  try {
+    execSync(`git branch -d "${branch}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+  recordOrchestrationEventBestEffort({
+    eventType: "worktree.pruned",
+    source: "worktree.cleanupWorktree",
+    agentId: employeeName,
+    instanceId: instance != null ? String(instance) : null,
+    payload: { branch, mainBranch }
+  });
+  return { cleaned: true, reason: `worktree and branch ${branch} removed (merged into ${mainBranch})` };
+}
+function branchExistsLocally(repoRoot, branch) {
+  try {
+    execSync(`git rev-parse --verify "refs/heads/${branch}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectMainBranch(repoRoot) {
+  for (const candidate of ["main", "master"]) {
+    if (branchExistsLocally(repoRoot, candidate)) return candidate;
+  }
+  return null;
+}
+function isBranchMerged(repoRoot, branch, into) {
+  try {
+    const merged = execSync(`git branch --merged "${into}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return merged.split("\n").map((l) => l.replace(/^[*+]?\s+/, "").trim()).includes(branch);
+  } catch {
+    return false;
+  }
+}
+function realpath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function ensureGitignoreEntry(repoRoot, entry) {
+  try {
+    const gitignorePath = path.join(repoRoot, ".gitignore");
+    if (existsSync(gitignorePath)) {
+      const content = readFileSync(gitignorePath, "utf-8");
+      if (content.includes(entry)) return;
+      appendFileSync(gitignorePath, `
+# Agent worktrees (exe-os)
+${entry}
+`);
+    } else {
+    }
+  } catch {
+  }
+}
+
+export {
+  getGitRoot,
+  getMainRepoRoot,
+  worktreePath,
+  worktreeBranch,
+  ensureWorktree,
+  isWorktreeDirty,
+  cleanupWorktree
+};

package/dist/chunk-FVKTXXKK.js

@@ -0,0 +1,128 @@
+import {
+  getCurrentSessionScope,
+  strictSessionScopeFilter
+} from "./chunk-6TLURATK.js";
+import {
+  getProjectName
+} from "./chunk-OPU3NYOO.js";
+
+// src/lib/session-events.ts
+import { randomUUID } from "crypto";
+async function ensureSessionEventsTable(client) {
+  await client.execute(`
+    CREATE TABLE IF NOT EXISTS session_events (
+      id            TEXT PRIMARY KEY,
+      agent_id      TEXT NOT NULL,
+      agent_role    TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      session_scope TEXT,
+      project_name  TEXT NOT NULL,
+      event_index   INTEGER NOT NULL,
+      event_type    TEXT NOT NULL,
+      tool_name     TEXT,
+      tool_use_id   TEXT,
+      content       TEXT NOT NULL,
+      payload_json  TEXT,
+      has_error     INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT NOT NULL
+    )
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_agent_time
+      ON session_events(agent_id, created_at DESC)
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_session_index
+      ON session_events(session_id, event_index)
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_scope_agent_time
+      ON session_events(session_scope, agent_id, created_at DESC)
+  `);
+}
+async function recordSessionEvent(client, input) {
+  if (!input.content || input.content.trim().length === 0) return;
+  await ensureSessionEventsTable(client);
+  const maxResult = await client.execute({
+    sql: "SELECT COALESCE(MAX(event_index), 0) AS max_index FROM session_events WHERE session_id = ?",
+    args: [input.sessionId]
+  });
+  const currentMax = Number(maxResult.rows[0]?.max_index ?? 0);
+  const eventIndex = Number.isFinite(currentMax) ? currentMax + 1 : 1;
+  await client.execute({
+    sql: `INSERT INTO session_events (
+            id, agent_id, agent_role, session_id, session_scope, project_name,
+            event_index, event_type, tool_name, tool_use_id, content,
+            payload_json, has_error, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      randomUUID(),
+      input.agentId,
+      input.agentRole,
+      input.sessionId,
+      input.sessionScope ?? getCurrentSessionScope(),
+      input.projectName ?? getProjectName(input.cwd),
+      eventIndex,
+      input.eventType,
+      input.toolName ?? null,
+      input.toolUseId ?? null,
+      input.content,
+      input.payloadJson ?? null,
+      input.hasError ? 1 : 0,
+      input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    ]
+  });
+}
+async function listRecentSessionEvents(client, options) {
+  await ensureSessionEventsTable(client);
+  const conditions = ["agent_id = ?"];
+  const args = [options.agentId];
+  if (options.sessionId) {
+    conditions.push("session_id = ?");
+    args.push(options.sessionId);
+  }
+  if (options.eventType) {
+    conditions.push("event_type = ?");
+    args.push(options.eventType);
+  }
+  if (options.projectName && options.projectName !== "all") {
+    conditions.push("project_name = ?");
+    args.push(options.projectName);
+  }
+  const scope = strictSessionScopeFilter(options.sessionScope);
+  const where = `WHERE ${conditions.join(" AND ")}${scope.sql}`;
+  args.push(...scope.args);
+  args.push(Math.min(Math.max(options.limit ?? 20, 1), 100));
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, agent_role, session_id, session_scope,
+                 project_name, event_index, event_type, tool_name, tool_use_id,
+                 content, payload_json, has_error, created_at
+          FROM session_events
+          ${where}
+          ORDER BY created_at DESC, event_index DESC
+          LIMIT ?`,
+    args
+  });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    agentId: String(row.agent_id),
+    agentRole: String(row.agent_role),
+    sessionId: String(row.session_id),
+    sessionScope: row.session_scope == null ? null : String(row.session_scope),
+    projectName: String(row.project_name),
+    eventIndex: Number(row.event_index),
+    eventType: String(row.event_type),
+    toolName: row.tool_name == null ? null : String(row.tool_name),
+    toolUseId: row.tool_use_id == null ? null : String(row.tool_use_id),
+    content: String(row.content),
+    payloadJson: row.payload_json == null ? null : String(row.payload_json),
+    hasError: Number(row.has_error) === 1,
+    createdAt: String(row.created_at)
+  }));
+}
+
+export {
+  ensureSessionEventsTable,
+  recordSessionEvent,
+  listRecentSessionEvents
+};

package/dist/chunk-FZDW76SH.js

@@ -0,0 +1,89 @@
+import {
+  getActiveAgent
+} from "./chunk-HJQQ7746.js";
+import {
+  listTasks
+} from "./chunk-F23GFLKY.js";
+import {
+  getAgentContext
+} from "./chunk-GJV3WDWM.js";
+import {
+  isCoordinatorName
+} from "./chunk-3X2ZT5FN.js";
+
+// src/mcp/tools/list-tasks.ts
+import { z } from "zod";
+function registerListTasks(server) {
+  server.registerTool(
+    "list_tasks",
+    {
+      title: "List Tasks",
+      description: "Query tasks by assignee, status, project, or priority. Defaults to current project. Pass project_name='all' for all projects. When querying your own tasks, project filter is skipped automatically.",
+      inputSchema: {
+        assigned_to: z.string().optional().describe("Filter by employee name"),
+        status: z.enum(["open", "in_progress", "done", "needs_review", "blocked", "cancelled", "closed"]).optional().describe("Filter by status. Default: active tasks only (excludes closed/cancelled)"),
+        project_name: z.string().optional().describe("Project name. Defaults to current project. Pass 'all' for all projects."),
+        priority: z.enum(["p0", "p1", "p2"]).optional().describe("Filter by priority"),
+        cross_session: z.boolean().optional().describe("When true, return tasks from ALL coordinator sessions (read-only). Default: false.")
+      }
+    },
+    async ({ assigned_to, status, project_name, priority, cross_session }) => {
+      try {
+        const { agentId } = getActiveAgent();
+        const isReviewQueue = status === "needs_review";
+        const shouldDefaultToOwnQueue = !assigned_to && !isReviewQueue && !isCoordinatorName(agentId);
+        const effectiveAssignedTo = assigned_to ?? (shouldDefaultToOwnQueue ? agentId : void 0);
+        const effectiveReviewer = !assigned_to && isReviewQueue ? agentId : void 0;
+        const isOwnQuery = effectiveAssignedTo === agentId;
+        const callerSession = getAgentContext()?.sessionHint || process.env.EXE_SESSION_NAME || process.env.EXE_SESSION || null;
+        const resolvedProject = project_name && project_name !== "all" ? project_name : null;
+        const effectiveCrossSession = cross_session === true;
+        const tasks = await listTasks({
+          assignedTo: effectiveAssignedTo,
+          reviewer: effectiveReviewer,
+          status,
+          projectName: resolvedProject,
+          priority,
+          crossSession: effectiveCrossSession,
+          isOwnQuery: !!isOwnQuery,
+          callerSession
+        });
+        if (tasks.length === 0) {
+          return {
+            content: [{ type: "text", text: "No tasks found." }]
+          };
+        }
+        const lines = tasks.map((t) => {
+          const cpIndicator = t.checkpointCount && t.checkpointCount > 0 ? ` [cp:${t.checkpointCount}]` : "";
+          let budgetNote = "";
+          if (t.budgetTokens !== null) {
+            const pct = Math.round(t.tokensUsed / t.budgetTokens * 100);
+            budgetNote = ` [${t.tokensUsed}/${t.budgetTokens} tokens, ${pct}%]`;
+          }
+          const shortId = t.id.slice(0, 8);
+          const sessionNote = cross_session && t.sessionScope ? ` [session:${t.sessionScope}]` : "";
+          return `- [${t.priority.toUpperCase()}] ${t.title} (${t.projectName}) \u2014 ${t.status}${cpIndicator}${budgetNote}${sessionNote} \u2192 ${t.assignedTo} [id:${shortId}]`;
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${tasks.length} task(s):
+${lines.join("\n")}`
+            }
+          ]
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Failed to list tasks: ${msg}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+export {
+  registerListTasks
+};