@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-42BHI7TN.js

@@ -0,0 +1,337 @@
+import {
+  getPersistentProcessRegistry
+} from "./chunk-NKNOBUBU.js";
+
+// src/ps-slash.ts
+import * as os from "node:os";
+var IDLE_THRESHOLD_MS = 2 * 6e4;
+var STALE_THRESHOLD_MS = 5 * 6e4;
+function now() {
+  return Date.now();
+}
+function formatAge(ms) {
+  if (ms < 1e3) return "0s";
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h`;
+  const days = Math.floor(hours / 24);
+  return `${days}d`;
+}
+function formatUptime(ms) {
+  return formatAge(ms);
+}
+function matchGlob(pattern, value) {
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  try {
+    const regex = new RegExp(`^${regexPattern}$`, "i");
+    return regex.test(value);
+  } catch {
+    return false;
+  }
+}
+async function listInstances(options = {}) {
+  const { includeStale = false, hostname: hostname2, status } = options;
+  const timestamp = now();
+  const registry = getPersistentProcessRegistry();
+  const globalStatus = await registry.getGlobalStatus();
+  const instances = [];
+  const instanceMap = globalStatus.instances;
+  for (const [instanceId, processes] of instanceMap) {
+    if (processes.length === 0) continue;
+    const mainProc = processes.find((p) => p.spawnMode === "main");
+    const firstProc = processes.at(0);
+    const mainPid = mainProc?.pid ?? firstProc?.pid ?? 0;
+    const hostname_ = firstProc?.hostname ?? os.hostname();
+    const startedAt = Math.min(...processes.map((p) => p.startedAt));
+    const lastActivity = Math.max(...processes.map((p) => p.lastHeartbeat));
+    const age = timestamp - lastActivity;
+    let instanceStatus = "stale";
+    if (age < IDLE_THRESHOLD_MS) instanceStatus = "active";
+    else if (age < STALE_THRESHOLD_MS) instanceStatus = "idle";
+    const sessionIds = /* @__PURE__ */ new Set();
+    for (const proc of processes) {
+      if (proc.sessionId) {
+        sessionIds.add(proc.sessionId);
+      }
+    }
+    if (!includeStale && instanceStatus === "stale") continue;
+    if (hostname2 && !matchGlob(hostname2, hostname_)) continue;
+    if (status && status !== "all" && instanceStatus !== status) continue;
+    instances.push({
+      instanceId,
+      hostname: hostname_,
+      mainPid,
+      startedAt,
+      lastActivity,
+      status: instanceStatus,
+      processCount: processes.length,
+      processes,
+      sessionIds
+    });
+  }
+  instances.sort((a, b) => b.lastActivity - a.lastActivity);
+  return instances;
+}
+async function getInstanceCount() {
+  const instances = await listInstances({ includeStale: true });
+  const byHostname = /* @__PURE__ */ new Map();
+  let active = 0;
+  let idle = 0;
+  let stale = 0;
+  for (const inst of instances) {
+    const current = byHostname.get(inst.hostname) ?? 0;
+    byHostname.set(inst.hostname, current + 1);
+    switch (inst.status) {
+      case "active":
+        active++;
+        break;
+      case "idle":
+        idle++;
+        break;
+      case "stale":
+        stale++;
+        break;
+    }
+  }
+  return {
+    total: instances.length,
+    active,
+    idle,
+    stale,
+    byHostname
+  };
+}
+async function getGlobalProcessStatus() {
+  const timestamp = now();
+  const registry = getPersistentProcessRegistry();
+  const globalStatus = await registry.getGlobalStatus();
+  const instances = await listInstances({ includeStale: true });
+  const localInstanceId = registry.getInstanceId();
+  const localInstance = instances.find((i) => i.instanceId === localInstanceId);
+  let localProtectedCount = 0;
+  if (localInstance) {
+    localProtectedCount = localInstance.processes.filter((p) => p.protected).length;
+  }
+  let activeInstanceCount = 0;
+  for (const inst of instances) {
+    if (inst.status === "active") activeInstanceCount++;
+  }
+  return {
+    localInstance: localInstance ? {
+      instanceId: localInstance.instanceId,
+      mainPid: localInstance.mainPid,
+      protectedCount: localProtectedCount,
+      platform: process.platform,
+      hostname: localInstance.hostname,
+      uptime: timestamp - localInstance.startedAt
+    } : {
+      instanceId: localInstanceId,
+      mainPid: process.pid,
+      protectedCount: 0,
+      platform: process.platform,
+      hostname: os.hostname(),
+      uptime: 0
+    },
+    allInstances: instances.map((inst) => ({
+      instanceId: inst.instanceId,
+      hostname: inst.hostname,
+      mainPid: inst.mainPid,
+      processes: inst.processes,
+      startedAt: inst.startedAt,
+      lastActivity: inst.lastActivity
+    })),
+    summary: {
+      totalProcesses: globalStatus.totalProcesses,
+      protectedCount: globalStatus.protectedCount,
+      staleCount: globalStatus.staleCount,
+      instanceCount: instances.length,
+      activeInstanceCount
+    },
+    timestamp
+  };
+}
+async function formatGlobalStatus() {
+  const status = await getGlobalProcessStatus();
+  const lines = [];
+  lines.push("=== WrongStack Global Process Status ===");
+  lines.push(`Updated: ${new Date(status.timestamp).toISOString()}`);
+  lines.push("");
+  lines.push("Summary:");
+  lines.push(`  Total processes: ${status.summary.totalProcesses}`);
+  lines.push(`  Protected: ${status.summary.protectedCount}`);
+  lines.push(`  Stale entries: ${status.summary.staleCount}`);
+  lines.push(
+    `  Instances: ${status.summary.instanceCount} (${status.summary.activeInstanceCount} active)`
+  );
+  lines.push("");
+  lines.push(`This instance (${status.localInstance.instanceId}):`);
+  lines.push(`  Main PID: ${status.localInstance.mainPid}`);
+  lines.push(`  Protected processes: ${status.localInstance.protectedCount}`);
+  lines.push(`  Platform: ${status.localInstance.platform} (${status.localInstance.hostname})`);
+  lines.push(`  Uptime: ${formatUptime(status.localInstance.uptime)}`);
+  lines.push("");
+  for (const instance of status.allInstances) {
+    if (instance.instanceId === status.localInstance.instanceId) continue;
+    const age = Math.round((status.timestamp - instance.lastActivity) / 1e3);
+    lines.push(`Instance ${instance.instanceId} (${instance.hostname}):`);
+    for (const proc of instance.processes) {
+      const procAge = formatAge(status.timestamp - proc.startedAt);
+      const heartbeatAge = formatAge(status.timestamp - proc.lastHeartbeat);
+      const protected_ = proc.protected ? "[P]" : "   ";
+      lines.push(
+        `  ${protected_} ${String(proc.pid).padStart(6)}  ${proc.name.padEnd(20)} started ${procAge.padStart(8)}  heartbeat ${heartbeatAge.padStart(6)}  ${proc.spawnMode}`
+      );
+    }
+    lines.push(`  Last activity: ${age}s ago`);
+    lines.push("");
+  }
+  lines.push("Legend:");
+  lines.push("  [P] = Protected (cannot be killed via bash)");
+  lines.push("  main = Main WrongStack process");
+  lines.push("  spawn = Spawned child process");
+  lines.push("  fork = Forked process (e.g., worker threads)");
+  return lines.join("\n");
+}
+async function formatInstanceList(options = {}) {
+  const instances = await listInstances(options);
+  const count = await getInstanceCount();
+  const lines = [];
+  lines.push("=== WrongStack Instances ===");
+  lines.push(
+    `Total: ${count.total} instances (${count.active} active, ${count.idle} idle, ${count.stale} stale)`
+  );
+  lines.push("");
+  if (count.byHostname.size > 1) {
+    lines.push("By hostname:");
+    for (const [host, num] of count.byHostname) {
+      lines.push(`  ${host}: ${num} instance${num !== 1 ? "s" : ""}`);
+    }
+    lines.push("");
+  }
+  if (instances.length === 0) {
+    lines.push("No instances found matching the filter.");
+    return lines.join("\n");
+  }
+  lines.push("INSTANCES:");
+  lines.push(
+    "  " + [
+      "STATUS".padEnd(7),
+      "HOSTNAME".padEnd(16),
+      "MAIN PID".padEnd(9),
+      "PROCS".padEnd(6),
+      "SESSIONS".padEnd(8),
+      "UPTIME".padEnd(8),
+      "LAST ACTIVITY"
+    ].join("  ")
+  );
+  lines.push("  " + "-".repeat(80));
+  for (const inst of instances) {
+    const uptime = formatAge(Date.now() - inst.startedAt);
+    const lastAct = formatAge(Date.now() - inst.lastActivity);
+    const statusIcon = inst.status === "active" ? "[*]" : inst.status === "idle" ? "[-]" : "[ ]";
+    lines.push(
+      "  " + [
+        `${statusIcon} ${inst.status}`.padEnd(7),
+        inst.hostname.padEnd(16),
+        String(inst.mainPid).padEnd(9),
+        String(inst.processCount).padEnd(6),
+        String(inst.sessionIds.size).padEnd(8),
+        uptime.padEnd(8),
+        `${lastAct} ago`
+      ].join("  ")
+    );
+  }
+  lines.push("");
+  lines.push("Use /ps full for detailed process listing per instance.");
+  return lines.join("\n");
+}
+async function formatInstanceSummary() {
+  const count = await getInstanceCount();
+  const instances = await listInstances({ includeStale: false });
+  if (instances.length === 0) {
+    return "No active WrongStack instances.";
+  }
+  const lines = [];
+  lines.push(`${count.total} instance${count.total !== 1 ? "s" : ""}`);
+  const byStatus = /* @__PURE__ */ new Map();
+  for (const inst of instances) {
+    byStatus.set(inst.status, (byStatus.get(inst.status) ?? 0) + 1);
+  }
+  const parts = [];
+  if (byStatus.get("active")) parts.push(`${byStatus.get("active")} active`);
+  if (byStatus.get("idle")) parts.push(`${byStatus.get("idle")} idle`);
+  if (byStatus.get("stale")) parts.push(`${byStatus.get("stale")} stale`);
+  lines.push(`(${parts.join(", ")})`);
+  const totalProcs = instances.reduce((sum, inst) => sum + inst.processCount, 0);
+  lines.push(`${totalProcs} total processes`);
+  return lines.join(" ");
+}
+function createGlobalPsSlashCommand() {
+  return {
+    name: "ps",
+    description: "List all WrongStack instances and their processes",
+    async handler(input) {
+      try {
+        const trimmed = input.trim();
+        const parts = trimmed.split(/\s+/);
+        const sub = parts[0]?.toLowerCase() ?? "";
+        if (sub === "list" || sub === "ls" || sub === "") {
+          const output = await formatInstanceList();
+          return { message: output };
+        }
+        if (sub === "summary" || sub === "sum") {
+          const output = await formatInstanceSummary();
+          return { message: output };
+        }
+        if (sub === "full" || sub === "detail") {
+          const output = await formatGlobalStatus();
+          return { message: output };
+        }
+        if (sub === "count" || sub === "num") {
+          const count = await getInstanceCount();
+          return {
+            message: `${count.total} instance${count.total !== 1 ? "s" : ""} (${count.active} active, ${count.idle} idle, ${count.stale} stale)`
+          };
+        }
+        if (sub === "hostname" || sub === "host") {
+          const pattern = parts.slice(1).join(" ");
+          if (!pattern) {
+            return { message: "Usage: /ps hostname <pattern> (e.g., /ps hostname workstation*)" };
+          }
+          const output = await formatInstanceList({ hostname: pattern });
+          return { message: output };
+        }
+        if (sub === "status" || sub === "state") {
+          const filterStatus = parts[1]?.toLowerCase();
+          if (!["active", "idle", "stale", "all"].includes(filterStatus ?? "")) {
+            return { message: "Usage: /ps status <active|idle|stale|all>" };
+          }
+          const output = await formatInstanceList({
+            status: filterStatus
+          });
+          return { message: output };
+        }
+        return {
+          message: "Usage: /ps [list|summary|count|full|hostname <pattern>|status <state>]"
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { message: `Error getting process status: ${message}` };
+      }
+    }
+  };
+}
+
+export {
+  listInstances,
+  getInstanceCount,
+  getGlobalProcessStatus,
+  formatGlobalStatus,
+  formatInstanceList,
+  formatInstanceSummary,
+  createGlobalPsSlashCommand
+};
+//# sourceMappingURL=chunk-42BHI7TN.js.map

package/dist/chunk-4BHUSMNL.js

@@ -0,0 +1,104 @@
+// src/mode.ts
+function modeFamily(mode) {
+  if (mode.tags?.includes("lite")) return "lite";
+  if (mode.tags?.includes("deep")) return "deep";
+  if (mode.tags?.includes("balanced") || mode.id === "default") return "balanced";
+  return "custom";
+}
+function createModeTool(modeStore) {
+  return {
+    name: "mode",
+    category: "Session",
+    description: "Manage agent operating modes. Modes change the agent's behavior, personality, and system prompt for different workflows (e.g. coding, security review, planning).",
+    usageHint: "POWERFUL BEHAVIOR CONTROL TOOL:\n\n- Use `list` to see available modes.\n- Use `set <modeId>` to switch the agent into a specific role/mode.\n- Use `get` to check current mode.\n- Use `clear` to return to default behavior.\nSwitching modes is very effective for specialized tasks. The mode change affects how the agent reasons and which guidelines it follows.",
+    permission: "confirm",
+    // WS-046: gives permission decisions something to key on — the mode being
+    // activated. Permission semantics are unchanged.
+    subjectKey: "mode",
+    mutating: true,
+    timeoutMs: 5e3,
+    capabilities: ["session.mode"],
+    icon: "settings",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["get", "list", "set", "clear"],
+          description: "The mode operation to perform."
+        },
+        mode: {
+          type: "string",
+          description: "The mode identifier to activate (only required when action=set)."
+        }
+      },
+      required: ["action"]
+    },
+    async execute(input) {
+      switch (input.action) {
+        case "get": {
+          const mode = await modeStore.getActiveMode();
+          return {
+            action: "get",
+            currentMode: mode?.id,
+            success: true,
+            message: mode ? `Current mode: ${mode.name} \u2014 ${mode.description}` : "No mode set (using default)"
+          };
+        }
+        case "list": {
+          const modes = await modeStore.listModes();
+          const lines = modes.map((m) => `  ${m.id.padEnd(20)} [${modeFamily(m)}] ${m.name} \u2014 ${m.description}`).join("\n");
+          return {
+            action: "list",
+            modes: modes.map((m) => ({
+              id: m.id,
+              name: m.name,
+              description: m.description,
+              family: modeFamily(m),
+              tags: m.tags ?? []
+            })),
+            success: true,
+            message: lines
+          };
+        }
+        case "set": {
+          if (!input.mode) {
+            return { action: "set", success: false, message: "mode is required for action=set" };
+          }
+          const mode = await modeStore.getMode(input.mode);
+          if (!mode) {
+            return { action: "set", success: false, message: `Mode "${input.mode}" not found` };
+          }
+          await modeStore.setActiveMode(input.mode);
+          return {
+            action: "set",
+            currentMode: mode.id,
+            success: true,
+            message: `Switched to mode: ${mode.name}
+
+${mode.description}`
+          };
+        }
+        case "clear": {
+          await modeStore.setActiveMode(null);
+          return {
+            action: "clear",
+            success: true,
+            message: "Mode cleared \u2014 using default mode"
+          };
+        }
+        default:
+          return {
+            action: input.action,
+            success: false,
+            message: `Unknown action "${input.action}"`
+          };
+      }
+    }
+  };
+}
+
+export {
+  createModeTool
+};
+//# sourceMappingURL=chunk-4BHUSMNL.js.map