@wrongstack/tools 0.310.1 → 0.313.1

package/dist/logs.js

@@ -1,291 +1,8 @@
-// src/logs.ts
-import { spawn } from "node:child_process";
-import { buildChildEnv } from "@wrongstack/core/utils";
-
-// src/_regex.ts
 import {
-  capSubject,
-  compileUserRegex,
-  MAX_SUBJECT_LEN
-} from "@wrongstack/primitives";
-
-// src/_util.ts
-import * as fsp from "node:fs/promises";
-import * as path from "node:path";
-import * as Core from "@wrongstack/core/utils";
-function resolvePath(input, ctx) {
-  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);
-}
-function allowedRoots(ctx) {
-  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];
-}
-function isInsideAny(target, roots) {
-  return roots.some((root) => {
-    const rel = path.relative(root, target);
-    return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
-  });
-}
-function ensureInsideRoot(absPath, ctx) {
-  const target = path.resolve(absPath);
-  if (ctx.allowOutsideProjectRoot) return target;
-  if (isInsideAny(target, allowedRoots(ctx))) return target;
-  throw new Error(`Path "${absPath}" is outside project root "${path.resolve(ctx.projectRoot)}"`);
-}
-function safeResolve(input, ctx) {
-  return ensureInsideRoot(resolvePath(input, ctx), ctx);
-}
-async function resolveRealInsideRoot(absPath, ctx) {
-  if (ctx.allowOutsideProjectRoot) return absPath;
-  const realRoots = await Promise.all(
-    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r)))
-  );
-  let probe = absPath;
-  const pendingTail = [];
-  for (; ; ) {
-    let real;
-    try {
-      real = await fsp.realpath(probe);
-    } catch (err) {
-      if (err.code === "ENOENT") {
-        const parent = path.dirname(probe);
-        if (parent === probe) return absPath;
-        pendingTail.unshift(path.basename(probe));
-        probe = parent;
-        continue;
-      }
-      throw err;
-    }
-    const candidate = pendingTail.length > 0 ? path.join(real, ...pendingTail) : real;
-    if (isInsideAny(candidate, realRoots)) {
-      return candidate;
-    }
-    throw new Error(
-      `Path "${absPath}" resolves through a symlink outside project root "${realRoots[0]}"`
-    );
-  }
-}
-async function safeResolveReal(input, ctx) {
-  const abs = safeResolve(input, ctx);
-  return await resolveRealInsideRoot(abs, ctx);
-}
-
-// src/logs.ts
-var logsTool = {
-  name: "logs",
-  category: "Logs",
-  description: "Read logs from files or Docker containers. Useful for debugging running applications.",
-  usageHint: "DEBUGGING TOOL \u2014 USE CAREFULLY IN AUTONOMOUS MODE:\n\n- Prefer `path` for local files or `service` for Docker containers.\n- Always use `filter` (regex) when possible to reduce noise and token usage.\n- `since` narrows Docker logs to a recent window.",
-  permission: "confirm",
-  mutating: false,
-  timeoutMs: 3e4,
-  maxOutputBytes: 262144,
-  capabilities: ["shell.restricted"],
-  icon: "logs",
-  inputSchema: {
-    type: "object",
-    properties: {
-      service: {
-        type: "string",
-        description: "Docker container name (passed to `docker logs`)"
-      },
-      path: {
-        type: "string",
-        description: "Path to log file (alternative to service)"
-      },
-      lines: {
-        type: "integer",
-        description: "Number of log lines to fetch (default: 100, 0 for all)",
-        minimum: 0,
-        maximum: 1e4
-      },
-      filter: {
-        type: "string",
-        description: "Regex pattern to filter log lines"
-      },
-      since: {
-        type: "string",
-        enum: ["1h", "6h", "24h", "all"],
-        description: 'Only show Docker logs since duration (ignored for files; "all" = no limit)'
-      },
-      cwd: { type: "string", description: "Working directory (default: cwd)" }
-    }
-  },
-  async execute(input, ctx, opts) {
-    const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
-    const lines = input.lines ?? 100;
-    let filterRe = null;
-    if (input.filter) {
-      const compiled = compileUserRegex(input.filter, "i");
-      if (!compiled.ok) {
-        throw new Error(`logs: ${compiled.reason}`);
-      }
-      filterRe = compiled.regex;
-    }
-    if (input.service) {
-      return await dockerLogs(input.service, lines, filterRe, cwd, opts.signal, input.since);
-    }
-    if (input.path) {
-      return await fileLogs(await safeResolveReal(input.path, ctx), lines, filterRe);
-    }
-    return {
-      source: "none",
-      entries: [],
-      total: 0,
-      truncated: false,
-      stream_mode: false
-    };
-  }
-};
-async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
-  const args = ["logs"];
-  if (lines > 0) args.push("--tail", String(lines));
-  if (since && since !== "all") {
-    const sinceMap = { "1h": "1h", "6h": "6h", "24h": "24h" };
-    args.push("--since", sinceMap[since] ?? "1h");
-  }
-  if (!/^[a-zA-Z0-9][a-zA-Z0-9._:-]+$/.test(service)) {
-    return {
-      source: `docker:${service}`,
-      entries: [],
-      total: 0,
-      truncated: false,
-      stream_mode: false
-    };
-  }
-  args.push("--timestamps", service);
-  return new Promise((resolve2) => {
-    let stdout = "";
-    let stderr = "";
-    const MAX = 2e5;
-    let settled = false;
-    const empty = () => ({
-      source: `docker:${service}`,
-      entries: [],
-      total: 0,
-      truncated: false,
-      stream_mode: false
-    });
-    const finish = (result) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve2(result);
-    };
-    const child = spawn("docker", args, {
-      cwd,
-      signal,
-      env: buildChildEnv(),
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true
-    });
-    const timer = setTimeout(() => {
-      child.kill("SIGTERM");
-      finish(empty());
-    }, DOCKER_LOGS_TIMEOUT_MS);
-    child.stdout?.on("data", (c) => {
-      if (stdout.length < MAX) stdout += c.toString();
-    });
-    child.stderr?.on("data", (c) => {
-      if (stderr.length < MAX) stderr += c.toString();
-    });
-    child.stdout?.on("error", (e) => {
-      console.log(
-        JSON.stringify({ level: "debug", event: "pipe_error", stream: "stdout", error: e.message })
-      );
-    });
-    child.stderr?.on("error", (e) => {
-      console.log(
-        JSON.stringify({ level: "debug", event: "pipe_error", stream: "stderr", error: e.message })
-      );
-    });
-    child.on("close", () => {
-      const output = stdout + stderr;
-      const entries = parseLogLines(output, filterRe);
-      finish({
-        source: `docker:${service}`,
-        entries,
-        total: entries.length,
-        truncated: output.length >= MAX,
-        stream_mode: false
-      });
-    });
-    child.on("error", () => finish(empty()));
-  });
-}
-var DOCKER_LOGS_TIMEOUT_MS = 3e3;
-var MAX_TAIL_LINES = 1e5;
-async function fileLogs(path2, lines, filterRe) {
-  const { createInterface } = await import("node:readline");
-  const { createReadStream } = await import("node:fs");
-  const entries = [];
-  const effLines = lines > 0 ? Math.min(lines, MAX_TAIL_LINES) : MAX_TAIL_LINES;
-  const window = new Array(effLines);
-  let writeIdx = 0;
-  let totalLines = 0;
-  const rl = createInterface({
-    input: createReadStream(path2),
-    crlfDelay: Number.POSITIVE_INFINITY
-  });
-  for await (const line of rl) {
-    if (filterRe && !filterRe.test(line)) continue;
-    window[writeIdx] = line;
-    writeIdx = (writeIdx + 1) % effLines;
-    totalLines++;
-  }
-  const ordered = [];
-  const start = totalLines >= effLines ? writeIdx : 0;
-  const count = Math.min(totalLines, effLines);
-  for (let i = 0; i < count; i++) {
-    const v = window[(start + i) % effLines];
-    if (v !== void 0) ordered.push(v);
-  }
-  for (const line of ordered) {
-    const parsed = parseLine(line);
-    if (parsed) entries.push(parsed);
-  }
-  return {
-    source: path2,
-    entries,
-    total: entries.length,
-    truncated: totalLines > effLines,
-    stream_mode: false
-  };
-}
-function parseLogLines(output, filterRe) {
-  const lines = output.split("\n").filter(Boolean);
-  const entries = [];
-  for (const line of lines) {
-    if (filterRe && !filterRe.test(line)) continue;
-    const parsed = parseLine(line);
-    if (parsed) entries.push(parsed);
-  }
-  return entries;
-}
-function parseLine(line) {
-  const tsRe = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)\s+(?:\[?(\w+)\]?)\s*(.*)/;
-  const match = tsRe.exec(line);
-  if (match) {
-    return {
-      timestamp: match[1] ?? "",
-      level: match[2]?.toLowerCase() ?? "info",
-      message: match[3] ?? ""
-    };
-  }
-  const levelRe = /(ERROR|WARN|INFO|DEBUG|TRACE)\s+(.*)/i;
-  const levelMatch = levelRe.exec(line);
-  if (levelMatch) {
-    return {
-      timestamp: "",
-      level: levelMatch[1]?.toLowerCase() ?? "info",
-      message: levelMatch[2] ?? line
-    };
-  }
-  return {
-    timestamp: "",
-    level: "info",
-    message: line
-  };
-}
+  logsTool
+} from "./chunk-RGISBZBD.js";
+import "./chunk-Q5JPPCZC.js";
+import "./chunk-D33S4RQG.js";
 export {
   logsTool
 };

package/dist/memory.js

@@ -1,218 +1,9 @@
-// src/memory.ts
-import { ToolValidationError } from "@wrongstack/core/types";
-function rememberTool(memory) {
-  return {
-    name: "remember",
-    category: "Session",
-    description: "Persist facts, conventions, decisions, and preferences into long-term memory. Memories survive restarts and are scored for relevance in future sessions.",
-    usageHint: "Persist facts, conventions, decisions, and preferences into long-term memory.\n\nWHEN TO USE:\n- Project conventions discovered during a task (build tool, lint rules, code style)\n- Architecture decisions made (chose X over Y, decided to use pattern Z)\n- User preferences expressed (prefers short names, always uses pnpm)\n- Anti-patterns identified (never do X, avoid pattern Y)\n- File/location references useful across sessions\n\nWHEN NOT TO USE:\n- Temporary task state or progress \u2192 use `todo`\n- One-off debugging notes\n- Information already obvious from the codebase\n\nAlways include `type` and `priority`. Use 1-3 `tags` for grouping.\nBetter to remember a fact now than rediscover it next session.",
-    permission: "confirm",
-    mutating: true,
-    timeoutMs: 2e3,
-    capabilities: ["memory.write"],
-    icon: "settings",
-    inputSchema: {
-      type: "object",
-      properties: {
-        text: {
-          type: "string",
-          description: "The fact or note to remember. Keep it concise and factual."
-        },
-        scope: {
-          type: "string",
-          enum: ["project-agents", "project-memory", "user-memory"],
-          description: "Where to store it: project-memory (shared), user-memory (personal), or project-agents."
-        },
-        type: {
-          type: "string",
-          enum: ["fact", "decision", "convention", "preference", "reference", "anti_pattern"],
-          description: "Category for filtering and relevance scoring."
-        },
-        tags: {
-          type: "array",
-          items: { type: "string" },
-          description: "Hashtag-style tags for grouping and search."
-        },
-        priority: {
-          type: "string",
-          enum: ["critical", "high", "medium", "low"],
-          description: "Priority level. Critical = always injected into context."
-        }
-      },
-      required: ["text"]
-    },
-    async execute(input) {
-      if (!input?.text) {
-        throw new ToolValidationError({
-          message: "remember: text is required",
-          field: "text"
-        });
-      }
-      const scope = input.scope ?? "project-memory";
-      await memory.remember(input.text, scope, {
-        type: input.type,
-        tags: input.tags,
-        priority: input.priority
-      });
-      return { ok: true, scope };
-    }
-  };
-}
-function forgetTool(memory) {
-  return {
-    name: "forget",
-    category: "Session",
-    description: "Remove memory entries that contain the given substring (case-insensitive). Use with caution. Pass `dry_run: true` to preview the matching entries (capped at 20) without deleting anything.",
-    usageHint: "This permanently deletes matching memories in the chosen scope.\n- Provide a reasonably specific `query` to avoid deleting unrelated memories.\n- Always double-check before calling with broad queries \u2014 `dry_run: true` previews the matches without deleting.\n- Use `remember` + `forget` together to maintain clean long-term memory.",
-    permission: "confirm",
-    // WS-046: gives permission decisions something to key on — the substring
-    // being forgotten.
-    subjectKey: "query",
-    mutating: true,
-    timeoutMs: 2e3,
-    capabilities: ["memory.delete"],
-    icon: "settings",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: { type: "string" },
-        scope: { type: "string", enum: ["project-agents", "project-memory", "user-memory"] },
-        dry_run: {
-          type: "boolean",
-          description: "When true, return the matched entries (capped at 20) WITHOUT deleting them. Default false."
-        }
-      },
-      required: ["query"]
-    },
-    async execute(input) {
-      if (!input?.query) {
-        throw new ToolValidationError({
-          message: "forget: query is required",
-          field: "query"
-        });
-      }
-      const scope = input.scope ?? "project-memory";
-      if (input.dry_run) {
-        const entries = await memory.list(scope);
-        const needle = input.query.toLowerCase();
-        const matching = entries.filter((entry) => entry.text.toLowerCase().includes(needle));
-        return {
-          removed: 0,
-          scope,
-          dryRun: true,
-          matched: matching.length,
-          matches: matching.slice(0, 20).map((entry) => entry.text)
-        };
-      }
-      const removed = await memory.forget(input.query, scope);
-      return { removed, scope };
-    }
-  };
-}
-function searchMemoryTool(memory) {
-  return {
-    name: "search_memory",
-    category: "Session",
-    description: "Search memory entries by content. With the default backend this does substring matching; semantic/graph backends use embedding similarity or graph traversal.",
-    usageHint: "Search long-term memory for relevant facts, conventions, or decisions.\n- Returns results ordered by relevance (newest-first for default, similarity for semantic).\n- Use before starting a task to recall project conventions and past decisions.\n- `limit` caps results (default 5, max 20).",
-    permission: "auto",
-    mutating: false,
-    timeoutMs: 2e3,
-    capabilities: ["memory.read"],
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description: "Search query \u2014 words or phrase to find in memory."
-        },
-        scope: {
-          type: "string",
-          enum: ["project-agents", "project-memory", "user-memory"],
-          description: "Which scope to search. Defaults to project-memory."
-        },
-        limit: {
-          type: "number",
-          description: "Maximum results to return (default 5, max 20)."
-        }
-      },
-      required: ["query"]
-    },
-    async execute(input) {
-      if (!input?.query) {
-        throw new ToolValidationError({
-          message: "search_memory: query is required",
-          field: "query"
-        });
-      }
-      const scope = input.scope ?? "project-memory";
-      const limit = Math.min(input.limit ?? 5, 20);
-      const entries = await memory.search(input.query, scope, limit);
-      return {
-        results: entries.map((e) => ({
-          text: e.text,
-          ts: e.ts,
-          scope: e.scope,
-          type: e.type,
-          tags: e.tags,
-          priority: e.priority
-        }))
-      };
-    }
-  };
-}
-function relatedMemoryTool(memory) {
-  return {
-    name: "find_related_memories",
-    category: "Session",
-    description: "Find memories related to the given text via graph traversal. Only available with graph backends; falls back to content search with file backends.",
-    usageHint: "Discover memories connected to a topic through co-occurrence or similarity edges.\n- Useful for exploring what else the project knows about a given concept.\n- Falls back to content search when no graph backend is configured.\n- `limit` caps results (default 5, max 20).",
-    permission: "auto",
-    mutating: false,
-    timeoutMs: 2e3,
-    capabilities: ["memory.read"],
-    inputSchema: {
-      type: "object",
-      properties: {
-        text: {
-          type: "string",
-          description: "Text to find related memories for."
-        },
-        scope: {
-          type: "string",
-          enum: ["project-agents", "project-memory", "user-memory"],
-          description: "Which scope to search. Defaults to project-memory."
-        },
-        limit: {
-          type: "number",
-          description: "Maximum results to return (default 5, max 20)."
-        }
-      },
-      required: ["text"]
-    },
-    async execute(input) {
-      if (!input?.text) {
-        throw new ToolValidationError({
-          message: "find_related_memories: text is required",
-          field: "text"
-        });
-      }
-      const scope = input.scope ?? "project-memory";
-      const limit = Math.min(input.limit ?? 5, 20);
-      const entries = memory.findRelated ? await memory.findRelated(input.text, scope, limit) : await memory.search(input.text, scope, limit);
-      return {
-        results: entries.map((e) => ({
-          text: e.text,
-          ts: e.ts,
-          scope: e.scope,
-          type: e.type,
-          tags: e.tags,
-          priority: e.priority
-        }))
-      };
-    }
-  };
-}
+import {
+  forgetTool,
+  relatedMemoryTool,
+  rememberTool,
+  searchMemoryTool
+} from "./chunk-WHIIIREL.js";
 export {
   forgetTool,
   relatedMemoryTool,

package/dist/mode.js

@@ -1,102 +1,6 @@
-// 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}"`
-          };
-      }
-    }
-  };
-}
+import {
+  createModeTool
+} from "./chunk-4BHUSMNL.js";
 export {
   createModeTool
 };