@wrongstack/cli 1.1.2 → 1.1.5

package/dist/tools-cli-44MLIUQO.js

@@ -0,0 +1,509 @@
+import {
+  createToolGateway,
+  parseCapabilityGrants,
+  resolveGatewayRegistry,
+  withheldReason
+} from "./chunk-LYWOV4OX.js";
+import "./chunk-W23PY4IJ.js";
+
+// src/subcommands/handlers/tools-cli.ts
+import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
+
+// src/subcommands/handlers/tools-cli-args.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { toErrorMessage } from "@wrongstack/core/utils";
+var ToolsCliUsageError = class extends Error {
+};
+var TOOLS_CLI_MAX_INPUT_BYTES = 8 * 1024 * 1024;
+var TOOLS_CLI_MAX_BATCH_CALLS = 500;
+async function readInputText(raw, cwd, readStdin) {
+  if (raw === void 0 || raw === false) return void 0;
+  let text;
+  let source;
+  if (raw === true || raw === "-") {
+    text = await readStdin();
+    source = "stdin";
+  } else if (raw.startsWith("@")) {
+    const file = path.resolve(cwd, raw.slice(1));
+    const stat2 = await fs.stat(file).catch((err) => {
+      throw new ToolsCliUsageError(`--input ${raw}: ${toErrorMessage(err)}`);
+    });
+    if (!stat2.isFile()) throw new ToolsCliUsageError(`--input ${raw}: not a regular file`);
+    if (stat2.size > TOOLS_CLI_MAX_INPUT_BYTES) {
+      throw new ToolsCliUsageError(
+        `--input ${raw}: larger than ${TOOLS_CLI_MAX_INPUT_BYTES} bytes`
+      );
+    }
+    text = await fs.readFile(file, "utf8");
+    source = raw;
+  } else {
+    text = raw;
+    source = "--input";
+  }
+  if (text.charCodeAt(0) === 65279) text = text.slice(1);
+  return { text, source };
+}
+function parseInputObject(text, source) {
+  const trimmed = text.trim();
+  if (trimmed === "") return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (err) {
+    throw new ToolsCliUsageError(`${source} is not valid JSON: ${toErrorMessage(err)}`);
+  }
+  if (!isPlainObject(parsed)) {
+    throw new ToolsCliUsageError(
+      `${source} must be a JSON object (the tool's input), not ${kindOf(parsed)}`
+    );
+  }
+  return parsed;
+}
+function parseSchemaArgs(tokens, schema) {
+  const properties = schema?.properties ?? {};
+  const out = {};
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i] ?? "";
+    if (!token.startsWith("--") || token === "--") {
+      throw new ToolsCliUsageError(
+        `unexpected argument "${token}" \u2014 tool fields are passed as --<field> <value>`
+      );
+    }
+    const eq = token.indexOf("=");
+    let key = eq === -1 ? token.slice(2) : token.slice(2, eq);
+    let inline = eq === -1 ? void 0 : token.slice(eq + 1);
+    let field = resolveField(key, properties);
+    if (!field && key.startsWith("no-") && inline === void 0) {
+      const negated = resolveField(key.slice(3), properties);
+      if (negated && primaryType(negated.schema) === "boolean") {
+        field = negated;
+        key = key.slice(3);
+        inline = "false";
+      }
+    }
+    if (!field) {
+      const names = Object.keys(properties);
+      throw new ToolsCliUsageError(
+        `unknown input field --${key}${names.length > 0 ? ` (fields: ${names.join(", ")})` : ""}`
+      );
+    }
+    const type = primaryType(field.schema);
+    let value = inline;
+    if (value === void 0) {
+      const next = tokens[i + 1];
+      if (type === "boolean" && (next === void 0 || next.startsWith("--"))) value = "true";
+      else if (next === void 0 || next.startsWith("--")) {
+        throw new ToolsCliUsageError(`--${key} needs a value`);
+      } else {
+        value = next;
+        i++;
+      }
+    }
+    const coerced = coerce(value, field.schema, `--${key}`);
+    if (type === "array" && !value.trim().startsWith("[")) {
+      const prior = out[field.name];
+      out[field.name] = Array.isArray(prior) ? [...prior, ...coerced] : coerced;
+    } else {
+      out[field.name] = coerced;
+    }
+  }
+  return out;
+}
+function parseBatchLines(text) {
+  const entries = [];
+  const lines = text.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index++) {
+    const raw = lines[index]?.trim() ?? "";
+    if (raw === "") continue;
+    const line = index + 1;
+    if (entries.length >= TOOLS_CLI_MAX_BATCH_CALLS) {
+      throw new ToolsCliUsageError(
+        `batch has more than ${TOOLS_CLI_MAX_BATCH_CALLS} calls; split it into several runs`
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      entries.push({ line, error: `line ${line} is not valid JSON: ${toErrorMessage(err)}` });
+      continue;
+    }
+    if (!isPlainObject(parsed)) {
+      entries.push({ line, error: `line ${line} must be a JSON object, not ${kindOf(parsed)}` });
+      continue;
+    }
+    const id = parsed["id"];
+    const tool = parsed["tool"];
+    const input = parsed["input"] ?? {};
+    if (typeof tool !== "string" || tool === "") {
+      entries.push({ line, id, error: `line ${line} needs a "tool" name` });
+    } else if (!isPlainObject(input)) {
+      entries.push({ line, id, error: `line ${line}: "input" must be a JSON object` });
+    } else {
+      entries.push({ line, id, tool, input });
+    }
+  }
+  return entries;
+}
+async function readStream(stream, maxBytes) {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of stream) {
+    const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    total += buf.byteLength;
+    if (total > maxBytes) throw new ToolsCliUsageError(`stdin input larger than ${maxBytes} bytes`);
+    chunks.push(buf);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function resolveField(key, properties) {
+  if (Object.hasOwn(properties, key)) return { name: key, schema: properties[key] ?? {} };
+  const camel = key.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+  if (Object.hasOwn(properties, camel)) return { name: camel, schema: properties[camel] ?? {} };
+  const snake = key.replace(/-/g, "_");
+  if (Object.hasOwn(properties, snake)) return { name: snake, schema: properties[snake] ?? {} };
+  return void 0;
+}
+function primaryType(schema) {
+  const type = schema.type;
+  if (typeof type === "string") return type;
+  if (Array.isArray(type))
+    return type.find((t) => typeof t === "string" && t !== "null");
+  return void 0;
+}
+function coerce(value, schema, label) {
+  switch (primaryType(schema)) {
+    case "string":
+      return value;
+    case "integer":
+    case "number": {
+      const n = Number(value);
+      const integer = primaryType(schema) === "integer";
+      if (value.trim() === "" || !Number.isFinite(n) || integer && !Number.isInteger(n)) {
+        throw new ToolsCliUsageError(
+          `${label} expects ${integer ? "an integer" : "a number"}, got "${value}"`
+        );
+      }
+      return n;
+    }
+    case "boolean":
+      if (value === "true") return true;
+      if (value === "false") return false;
+      throw new ToolsCliUsageError(`${label} expects true or false, got "${value}"`);
+    case "array": {
+      if (value.trim().startsWith("[")) return parseJsonValue(value, label);
+      const items = schema.items ?? {};
+      return [coerce(value, items, label)];
+    }
+    case "object":
+      return parseJsonValue(value, label);
+    default: {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+  }
+}
+function parseJsonValue(value, label) {
+  try {
+    return JSON.parse(value);
+  } catch (err) {
+    throw new ToolsCliUsageError(`${label} expects JSON: ${toErrorMessage(err)}`);
+  }
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function kindOf(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  return `a ${typeof value}`;
+}
+
+// src/subcommands/handlers/tools-cli.ts
+var TOOLS_CLI_EXIT = {
+  ok: 0,
+  toolFailed: 1,
+  usage: 2,
+  notExposed: 3,
+  confirmRequired: 4
+};
+var processIo = {
+  stdout: (text) => process.stdout.write(text),
+  stderr: (text) => process.stderr.write(text),
+  readStdin: async () => {
+    if (process.stdin.isTTY) {
+      throw new ToolsCliUsageError("a bare --input reads from stdin, but stdin is a terminal");
+    }
+    return readStream(process.stdin, TOOLS_CLI_MAX_INPUT_BYTES);
+  }
+};
+async function runToolsCli(verb, args, deps, io = processIo) {
+  if (verb === "serve") {
+    const { serveToolsCommand } = await import("./tools-serve-TRCET2M7.js");
+    return serveToolsCommand(args, deps, io);
+  }
+  const flags = deps.flags ?? {};
+  const json = flags["json"] === true;
+  let allow;
+  try {
+    allow = parseCapabilityGrants(flags["allow"]);
+  } catch (err) {
+    io.stderr(`${toErrorMessage2(err)}
+`);
+    return TOOLS_CLI_EXIT.usage;
+  }
+  const registry = resolveGatewayRegistry(deps.toolRegistry, deps.config);
+  const gateway = await createToolGateway({
+    registry,
+    config: deps.config,
+    cwd: deps.cwd,
+    projectRoot: deps.projectRoot,
+    yolo: flags["yolo"] === true || flags["allow-all"] === true,
+    allow,
+    whitelist: null,
+    oneShot: true,
+    onWarning: (message) => io.stderr(`wstack tools: ${message}
+`)
+  });
+  try {
+    if (verb === "list") return listTools(gateway, json, io);
+    if (verb === "agent-guide") {
+      io.stdout(toolsAgentGuide(gateway));
+      return TOOLS_CLI_EXIT.ok;
+    }
+    if (verb === "batch") return await runBatch(gateway, registry, flags, deps.cwd, io);
+    const [name, ...rest] = args;
+    if (!name) {
+      io.stderr(
+        `Usage: wstack tools ${verb} <tool>${verb === "run" ? " [--input <json>] [-- --<field> <value> ...]" : ""}
+`
+      );
+      return TOOLS_CLI_EXIT.usage;
+    }
+    if (verb === "describe") return describeTool(gateway, registry, name, json, io);
+    const fieldArgs = flags["input"] === true && rest[0] === "-" ? rest.slice(1) : rest;
+    const outcome = await runOne(gateway, registry, name, fieldArgs, flags, deps.cwd, io);
+    printRun(outcome, json, io);
+    return outcome.code;
+  } finally {
+    await gateway.close();
+  }
+}
+function listTools(gateway, json, io) {
+  if (json) {
+    io.stdout(
+      `${JSON.stringify({
+        mode: gateway.mode,
+        capabilities: gateway.capabilities,
+        tools: gateway.tools.map((t) => ({
+          name: t.name,
+          permission: t.permission,
+          capabilities: t.capabilities ?? [],
+          summary: summaryOf(t)
+        }))
+      })}
+`
+    );
+    return TOOLS_CLI_EXIT.ok;
+  }
+  const width = Math.max(0, ...gateway.tools.map((t) => t.name.length)) + 2;
+  for (const t of gateway.tools) io.stdout(`${t.name.padEnd(width)}${summaryOf(t)}
+`);
+  io.stderr(
+    `${gateway.tools.length} tool(s) exposed (${modeLabel(gateway)}). \`wstack tools describe <tool>\` shows the input schema.
+`
+  );
+  return TOOLS_CLI_EXIT.ok;
+}
+var GUIDE_INDEX_TOOLS = [
+  ["codebase-context", '--query "<task>"', "files and declarations a task touches"],
+  ["codebase-search", "--query <name>", "where something is defined"],
+  ["codebase-incoming-calls", "--symbol <name>", "who calls it"],
+  ["codebase-outgoing-calls", "--symbol <name>", "what it calls"],
+  ["codebase-read-symbol", "--file <path> --symbol <name>", "one symbol's source"],
+  ["codebase-skeleton", "--path <file-or-dir>", "an outline without bodies"],
+  ["codebase-impact-analysis", "--symbol <name>", "what a change affects"]
+];
+function toolsAgentGuide(gateway) {
+  const exposed = new Set(gateway.tools.map((t) => t.name));
+  const index = GUIDE_INDEX_TOOLS.filter(([name]) => exposed.has(name));
+  const grant = gateway.mode === "safe" ? "Read-only by default. Writes and commands need an explicit grant, e.g. `--allow fs.write`." : `Exposed with ${gateway.mode === "yolo" ? "--yolo" : `--allow ${gateway.capabilities.join(",")}`}; pass the same flag on every call.`;
+  return [
+    "## WrongStack tools",
+    "",
+    "This is a WrongStack project. WrongStack's built-in tools run from the shell, one call per command:",
+    "",
+    "```sh",
+    "wstack tools list                              # names and one-line summaries",
+    "wstack tools describe <tool>                   # a tool's fields (JSON schema)",
+    "wstack tools run <tool> -- --<field> <value>   # fields after `--`, typed by the schema",
+    "wstack tools run <tool> --input '<json>'       # or --input @call.json, or a bare --input for stdin",
+    'wstack tools batch < calls.jsonl               # {"tool":\u2026,"input":\u2026,"id":\u2026} per line, one process',
+    "```",
+    "",
+    ...index.length > 0 ? [
+      "For code navigation prefer the codebase index over grep/glob and whole-file reads; it is",
+      "caught up with the disk on every call:",
+      "",
+      ...index.map(
+        ([name, fields, use]) => `- \`wstack tools run ${name} -- ${fields}\` \u2014 ${use}`
+      ),
+      ""
+    ] : [],
+    `- ${grant} The user's deny rules always apply; deleting outside the project, history-rewriting git and download-and-run commands are refused.`,
+    "- Exit codes: 0 ok \xB7 1 tool failed \xB7 2 bad input \xB7 3 not exposed or denied \xB7 4 needs a confirmation. Add `--json` for a `{ok, settlement, content}` envelope.",
+    "",
+    `Tools exposed here (${gateway.tools.length}): ${gateway.tools.map((t) => t.name).join(", ")}.`,
+    ""
+  ].join("\n");
+}
+function describeTool(gateway, registry, name, json, io) {
+  const tool = gateway.get(name);
+  if (!tool) {
+    const outcome = notExposed(gateway, registry, name);
+    printRun(outcome, json, io);
+    return outcome.code;
+  }
+  const inputSchema = tool.inputSchema ?? { type: "object" };
+  if (json) {
+    io.stdout(
+      `${JSON.stringify({
+        name: tool.name,
+        permission: tool.permission,
+        capabilities: tool.capabilities ?? [],
+        description: tool.description,
+        inputSchema
+      })}
+`
+    );
+    return TOOLS_CLI_EXIT.ok;
+  }
+  io.stdout(
+    `${tool.name} (${tool.permission})
+
+${tool.description.trim()}
+
+Input schema:
+${JSON.stringify(inputSchema, null, 2)}
+
+Run: wstack tools run ${tool.name} --input '<json>'   (or --input @file.json, a bare --input for stdin,
+     or schema fields after --: wstack tools run ${tool.name} -- --<field> <value>)
+`
+  );
+  return TOOLS_CLI_EXIT.ok;
+}
+async function runOne(gateway, registry, name, fieldArgs, flags, cwd, io) {
+  const tool = gateway.get(name);
+  if (!tool) return notExposed(gateway, registry, name);
+  let input;
+  try {
+    const raw = await readInputText(flags["input"], cwd, () => io.readStdin());
+    input = {
+      ...raw ? parseInputObject(raw.text, raw.source) : {},
+      ...parseSchemaArgs(fieldArgs, tool.inputSchema)
+    };
+  } catch (err) {
+    return failure(name, "invalid_input", toErrorMessage2(err), TOOLS_CLI_EXIT.usage);
+  }
+  return call(gateway, registry, name, input);
+}
+async function call(gateway, registry, name, input) {
+  const outcome = await gateway.call(name, input);
+  if (outcome.kind === "not_exposed") return notExposed(gateway, registry, name);
+  if (outcome.kind === "confirm_required") {
+    return failure(
+      name,
+      "confirm_required",
+      `Tool "${name}" needs an interactive confirmation for this input, which \`wstack tools\` cannot give.`,
+      TOOLS_CLI_EXIT.confirmRequired
+    );
+  }
+  const code = exitCodeFor(outcome.settlement, outcome.isError);
+  return {
+    code,
+    report: {
+      ok: code === TOOLS_CLI_EXIT.ok,
+      tool: name,
+      settlement: outcome.settlement,
+      durationMs: outcome.durationMs,
+      content: outcome.content
+    }
+  };
+}
+async function runBatch(gateway, registry, flags, cwd, io) {
+  let entries;
+  try {
+    const raw = await readInputText(flags["input"] ?? true, cwd, () => io.readStdin());
+    entries = parseBatchLines(raw?.text ?? "");
+  } catch (err) {
+    io.stderr(`${toErrorMessage2(err)}
+`);
+    return TOOLS_CLI_EXIT.usage;
+  }
+  let exit = TOOLS_CLI_EXIT.ok;
+  for (const entry of entries) {
+    const outcome = "error" in entry ? failure("", "invalid_input", entry.error, TOOLS_CLI_EXIT.usage) : await call(gateway, registry, entry.tool, entry.input);
+    if (exit === TOOLS_CLI_EXIT.ok) exit = outcome.code;
+    const id = entry.id === void 0 ? {} : { id: entry.id };
+    io.stdout(`${JSON.stringify({ line: entry.line, ...id, ...outcome.report })}
+`);
+  }
+  return exit;
+}
+function printRun(outcome, json, io) {
+  const { report } = outcome;
+  if (json) {
+    io.stdout(`${JSON.stringify(report)}
+`);
+    return;
+  }
+  const text = "content" in report ? report.content : report.message;
+  const line = text.endsWith("\n") ? text : `${text}
+`;
+  if (outcome.code === TOOLS_CLI_EXIT.ok) io.stdout(line);
+  else io.stderr(line);
+}
+function exitCodeFor(settlement, isError) {
+  switch (settlement) {
+    case "completed":
+      return isError ? TOOLS_CLI_EXIT.toolFailed : TOOLS_CLI_EXIT.ok;
+    case "invalid_input":
+      return TOOLS_CLI_EXIT.usage;
+    case "unknown_tool":
+    case "denied_by_policy":
+    case "blocked_by_hook":
+      return TOOLS_CLI_EXIT.notExposed;
+    case "declined":
+      return TOOLS_CLI_EXIT.confirmRequired;
+    default:
+      return TOOLS_CLI_EXIT.toolFailed;
+  }
+}
+function notExposed(gateway, registry, name) {
+  return failure(
+    name,
+    "not_exposed",
+    withheldReason(gateway, registry, name),
+    TOOLS_CLI_EXIT.notExposed
+  );
+}
+function failure(tool, error, message, code) {
+  return { code, report: { ok: false, tool, error, message } };
+}
+function summaryOf(tool) {
+  const first = tool.description.trim().split("\n")[0]?.trim() ?? "";
+  return first.length > 160 ? `${first.slice(0, 157)}...` : first;
+}
+function modeLabel(gateway) {
+  if (gateway.mode === "yolo") return "yolo: every capability";
+  if (gateway.mode === "granted") return `granted: ${gateway.capabilities.join(", ")}`;
+  return "safe: read-only";
+}
+export {
+  runToolsCli
+};
+//# sourceMappingURL=tools-cli-44MLIUQO.js.map

package/dist/tools-serve-TRCET2M7.js

@@ -0,0 +1,102 @@
+import {
+  serveToolGatewayHttp
+} from "./chunk-RN5CFAVQ.js";
+import {
+  parseToolsFlag,
+  resolveServeHttpPort
+} from "./chunk-QLYPIJ7X.js";
+import {
+  createToolGateway,
+  parseCapabilityGrants,
+  resolveGatewayRegistry
+} from "./chunk-LYWOV4OX.js";
+import "./chunk-W23PY4IJ.js";
+
+// src/subcommands/handlers/tools-serve.ts
+import { randomBytes } from "node:crypto";
+import { toErrorMessage } from "@wrongstack/core/utils";
+async function serveToolsCommand(args, deps, io, waitForShutdown = untilSignal) {
+  const flags = deps.flags ?? {};
+  let allow;
+  let port;
+  try {
+    allow = parseCapabilityGrants(flags["allow"]);
+    port = resolveServeHttpPort(flags);
+  } catch (err) {
+    io.stderr(`wstack tools serve: ${toErrorMessage(err)}
+`);
+    return 2;
+  }
+  const whitelist = parseToolsFlag(flags, args);
+  if (flags["tools"] !== void 0 && whitelist === null) {
+    io.stderr("wstack tools serve: --tools needs a comma-separated tool list\n");
+    return 2;
+  }
+  const host = typeof flags["host"] === "string" ? flags["host"] : "127.0.0.1";
+  const envToken = process.env.WRONGSTACK_TOOLS_TOKEN?.trim();
+  const flagToken = typeof flags["token"] === "string" ? flags["token"] : void 0;
+  if (flagToken) {
+    io.stderr(
+      "wstack tools serve: --token puts the token on the command line, where other local processes can read it. Prefer WRONGSTACK_TOOLS_TOKEN.\n"
+    );
+  }
+  const generated = !flagToken && !envToken;
+  const token = flagToken ?? envToken ?? randomBytes(24).toString("hex");
+  const registry = resolveGatewayRegistry(deps.toolRegistry, deps.config);
+  const gateway = await createToolGateway({
+    registry,
+    config: deps.config,
+    cwd: deps.cwd,
+    projectRoot: deps.projectRoot,
+    yolo: flags["yolo"] === true || flags["allow-all"] === true,
+    allow,
+    whitelist,
+    remoteAgent: true,
+    onWarning: (message) => io.stderr(`wstack tools serve: ${message}
+`)
+  });
+  try {
+    const handle = await serveToolGatewayHttp({
+      gateway,
+      registry,
+      token,
+      port,
+      host,
+      allowRemoteCallbacks: flags["allow-remote-callbacks"] === true,
+      log: (message) => io.stderr(`${message}
+`)
+    });
+    io.stdout(
+      `${JSON.stringify({
+        url: handle.url,
+        ...generated ? { token } : {},
+        mode: gateway.mode,
+        tools: gateway.tools.length
+      })}
+`
+    );
+    io.stderr(
+      `wstack tools serve: ${gateway.tools.length} tool(s) at ${handle.url} (${gateway.mode}). GET /v1/tools, POST /v1/tools/<name>/call with Authorization: Bearer <token>.
+`
+    );
+    await waitForShutdown();
+    await handle.close();
+    return 0;
+  } catch (err) {
+    io.stderr(`wstack tools serve: ${toErrorMessage(err)}
+`);
+    return 1;
+  } finally {
+    await gateway.close();
+  }
+}
+function untilSignal() {
+  return new Promise((resolve) => {
+    process.once("SIGINT", () => resolve());
+    process.once("SIGTERM", () => resolve());
+  });
+}
+export {
+  serveToolsCommand
+};
+//# sourceMappingURL=tools-serve-TRCET2M7.js.map

package/dist/{tools-skills-55QVTMSK.js → tools-skills-WDTMCE46.js}

@@ -2,7 +2,12 @@ import "./chunk-W23PY4IJ.js";
 
 // src/subcommands/handlers/tools-skills.ts
 import { color } from "@wrongstack/core/utils";
-var toolsCmd = async (_args, deps) => {
+var toolsCmd = async (args, deps) => {
+  const verb = args[0] ?? "";
+  if (["list", "describe", "run", "batch", "agent-guide", "serve"].includes(verb)) {
+    const { runToolsCli } = await import("./tools-cli-44MLIUQO.js");
+    return runToolsCli(verb, args.slice(1), deps);
+  }
   const reg = deps.toolRegistry;
   if (!reg) return 0;
   for (const { tool, owner } of reg.listWithOwner())
@@ -26,4 +31,4 @@ export {
   skillsCmd,
   toolsCmd
 };
-//# sourceMappingURL=tools-skills-55QVTMSK.js.map
+//# sourceMappingURL=tools-skills-WDTMCE46.js.map

package/dist/tuneup-runtime-checks.d.ts

@@ -0,0 +1,7 @@
+import type { TuneupFinding, TuneupInput } from './tuneup-types.js';
+/** True when `command` is safely read-only by our conservative heuristic. */
+export declare function isReadOnlyCommand(command: string): boolean;
+export declare function checkPermissions(input: TuneupInput): TuneupFinding[];
+export declare function checkPerformance(input: TuneupInput): TuneupFinding[];
+export declare function checkReliability(input: TuneupInput): TuneupFinding[];
+//# sourceMappingURL=tuneup-runtime-checks.d.ts.map