@wrongstack/tools 0.310.1 → 0.313.1

package/dist/chunk-ILESNGNM.js

@@ -0,0 +1,163 @@
+// src/codebase-index/languages.ts
+import * as path from "node:path";
+var EXT_TO_LANG = {
+  // TypeScript / JavaScript (first-class TS compiler API)
+  ".ts": "ts",
+  ".mts": "ts",
+  ".cts": "ts",
+  ".tsx": "tsx",
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".jsx": "jsx",
+  // First-class native/spawn parsers (+ regex fallback)
+  ".go": "go",
+  ".py": "py",
+  ".pyi": "py",
+  ".pyw": "py",
+  ".rs": "rs",
+  ".json": "json",
+  ".jsonc": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  // C family
+  ".c": "c",
+  ".h": "c",
+  ".cc": "cpp",
+  ".cpp": "cpp",
+  ".cxx": "cpp",
+  ".hh": "cpp",
+  ".hpp": "cpp",
+  ".hxx": "cpp",
+  // JVM / .NET
+  ".java": "java",
+  ".cs": "csharp",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".scala": "scala",
+  ".sc": "scala",
+  // Scripting
+  ".php": "php",
+  ".rb": "ruby",
+  ".swift": "swift",
+  ".dart": "dart",
+  ".lua": "lua",
+  ".r": "r",
+  ".R": "r",
+  ".pl": "other",
+  ".pm": "other",
+  // Systems / functional
+  ".zig": "zig",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".hs": "haskell",
+  ".lhs": "haskell",
+  // Shell / data / docs / web
+  ".sh": "shell",
+  ".bash": "shell",
+  ".zsh": "shell",
+  ".ps1": "shell",
+  ".sql": "sql",
+  ".md": "md",
+  ".mdx": "md",
+  ".toml": "toml",
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".scss": "css",
+  ".less": "css",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".proto": "proto",
+  ".graphql": "graphql",
+  ".gql": "graphql"
+};
+var INDEXABLE_EXTENSIONS = Object.freeze(
+  [...new Set(Object.keys(EXT_TO_LANG).map((e) => e.toLowerCase()))].sort()
+);
+var SPECIAL_FILENAMES = {
+  makefile: "other",
+  gnumakefile: "other",
+  dockerfile: "other",
+  "docker-compose.yml": "yaml",
+  "docker-compose.yaml": "yaml",
+  "cmakelists.txt": "other",
+  gemfile: "ruby",
+  rakefile: "ruby",
+  procfile: "other",
+  justfile: "other"
+};
+function detectLang(file) {
+  const base = path.basename(file);
+  const lowerBase = base.toLowerCase();
+  if (lowerBase.endsWith(".d.ts") || lowerBase.endsWith(".d.mts") || lowerBase.endsWith(".d.cts")) {
+    return "ts";
+  }
+  const special = SPECIAL_FILENAMES[lowerBase];
+  if (special) return special;
+  const ext = path.extname(base).toLowerCase();
+  if (!ext) return null;
+  return EXT_TO_LANG[ext] ?? null;
+}
+function isIndexablePath(file) {
+  return detectLang(file) !== null;
+}
+var LANG_FAMILY = {
+  // Single-compilation-unit family: a .vue/.svelte script block is JS/TS and
+  // imports from — and is imported by — plain .ts files.
+  ts: "js",
+  tsx: "js",
+  js: "js",
+  jsx: "js",
+  vue: "js",
+  svelte: "js",
+  go: "go",
+  py: "py",
+  rs: "rs",
+  // The JVM resolves across languages: Kotlin and Scala call Java directly.
+  java: "jvm",
+  kotlin: "jvm",
+  scala: "jvm",
+  csharp: "dotnet",
+  // A .h header is consumed by both C and C++ translation units.
+  c: "c",
+  cpp: "c",
+  ruby: "ruby",
+  php: "php",
+  swift: "swift",
+  dart: "dart",
+  elixir: "elixir",
+  haskell: "haskell",
+  zig: "zig",
+  lua: "lua",
+  r: "r",
+  shell: "shell",
+  sql: "sql",
+  json: "data",
+  yaml: "data",
+  toml: "data",
+  html: "web",
+  css: "web",
+  proto: "proto",
+  graphql: "graphql",
+  md: "other",
+  other: "other"
+};
+var LANG_FAMILY_ENTRIES = Object.freeze(
+  Object.entries(LANG_FAMILY).map(
+    ([lang, family]) => Object.freeze([lang, family])
+  )
+);
+function languageFamily(lang) {
+  return LANG_FAMILY[lang] ?? "other";
+}
+
+export {
+  EXT_TO_LANG,
+  INDEXABLE_EXTENSIONS,
+  detectLang,
+  isIndexablePath,
+  LANG_FAMILY_ENTRIES,
+  languageFamily
+};
+//# sourceMappingURL=chunk-ILESNGNM.js.map

package/dist/chunk-INF5CGAO.js

@@ -0,0 +1,137 @@
+import {
+  tryLegacyCodeOperation
+} from "./chunk-NHA6BEIH.js";
+import {
+  spawnStream
+} from "./chunk-MAN26PZ5.js";
+import {
+  detectPackageManager,
+  normalizeCommandOutput,
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/typecheck.ts
+import * as path from "node:path";
+var typecheckTool = {
+  name: "typecheck",
+  category: "Code Quality",
+  description: "Run the project's TypeScript type checker (`tsc --noEmit` or equivalent). Essential for verifying type safety before making changes or committing.",
+  usageHint: "ALWAYS RUN BEFORE CONSIDERING WORK COMPLETE:\n\n- Use this to catch type errors early.\n- In monorepos, `all: true` will check every package.\n- This is one of the most important quality gates in this project.\nNever claim a task is done without a clean typecheck (unless the user explicitly says otherwise).",
+  permission: "confirm",
+  mutating: false,
+  timeoutMs: 12e4,
+  capabilities: ["shell.restricted"],
+  icon: "code",
+  inputSchema: {
+    type: "object",
+    properties: {
+      project: { type: "string", description: "Path to tsconfig.json (default: auto-detect)" },
+      cwd: { type: "string", description: "Working directory (default: cwd)" },
+      strict: {
+        type: "boolean",
+        description: "Add --strict flag for maximum type checking (default: false)"
+      },
+      all: {
+        type: "boolean",
+        description: "Type-check all workspace packages (pnpm workspaces run `pnpm -r exec tsc --noEmit`; other setups run a single `tsc --noEmit` at cwd) (default: false)"
+      }
+    }
+  },
+  async execute(input, ctx, opts) {
+    let final;
+    const executeStream = typecheckTool.executeStream;
+    if (!executeStream) throw new Error("typecheckTool: stream execution unavailable");
+    for await (const ev of executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("typecheck: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
+    const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
+    const bridge = await tryLegacyCodeOperation("semantic", {
+      cwd,
+      projectRoot: ctx.projectRoot,
+      signal: opts.signal
+    });
+    if (bridge?.run) {
+      const run = bridge.run;
+      yield {
+        type: "final",
+        output: {
+          project: `${bridge.language} workspace`,
+          exit_code: run.exitCode ?? 0,
+          errors: run.summary.errors,
+          warnings: run.summary.warnings,
+          output: normalizeCommandOutput(run.output || run.error || ""),
+          truncated: run.truncated
+        }
+      };
+      return;
+    }
+    let cmd;
+    let cmdArgs;
+    let project;
+    if (input.all) {
+      project = "workspace";
+      const tscArgs = ["--noEmit"];
+      if (input.strict) tscArgs.push("--strict");
+      const manager = await detectPackageManager(cwd, ctx.projectRoot);
+      if (manager === "pnpm") {
+        cmd = "pnpm";
+        cmdArgs = ["-r", "--no-bail", "exec", "tsc", ...tscArgs];
+      } else {
+        cmd = "npx";
+        cmdArgs = ["tsc", ...tscArgs];
+      }
+    } else {
+      const tsconfig = input.project ? await safeResolveReal(input.project, ctx) : await findTsConfig(cwd);
+      const tscArgs = ["--noEmit"];
+      if (input.strict) tscArgs.push("--strict");
+      if (tsconfig) tscArgs.push("--project", tsconfig);
+      project = tsconfig ?? "default";
+      cmd = "npx";
+      cmdArgs = ["tsc", ...tscArgs];
+    }
+    yield { type: "log", text: `${cmd} ${cmdArgs.join(" ")}`, data: { project } };
+    const result = yield* spawnStream({
+      cmd,
+      args: cmdArgs,
+      cwd,
+      signal: opts.signal,
+      maxBytes: 2e5
+    });
+    const combined = `${result.stdout}
+${result.stderr}`;
+    const errors = [...combined.matchAll(/^.*\berror TS\d+:/gm)].length;
+    const warnings = [...combined.matchAll(/^.*\bwarning TS\d+:/gm)].length;
+    yield {
+      type: "final",
+      output: {
+        project,
+        exit_code: result.exitCode,
+        errors,
+        warnings,
+        output: normalizeCommandOutput(result.stdout || result.stderr || result.error || ""),
+        truncated: result.truncated
+      }
+    };
+  }
+};
+async function findTsConfig(cwd) {
+  const { stat } = await import("node:fs/promises");
+  const candidates = ["tsconfig.json", "tsconfig.base.json"];
+  for (const f of candidates) {
+    try {
+      const s = await stat(path.join(cwd, f));
+      if (s.isFile()) return path.join(cwd, f);
+    } catch {
+    }
+  }
+  return null;
+}
+
+export {
+  typecheckTool
+};
+//# sourceMappingURL=chunk-INF5CGAO.js.map

package/dist/chunk-IWDFZ6XR.js

@@ -0,0 +1,337 @@
+import {
+  getPersistentProcessRegistry
+} from "./chunk-ZIGAZFWE.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-IWDFZ6XR.js.map