@wrongstack/tools 1.0.2 → 1.0.4

package/dist/chunk-CHEK3ASV.js

@@ -1,183 +0,0 @@
-import {
-  ensureInsideRoot,
-  safeResolveReal
-} from "./chunk-ZUFHAHTE.js";
-
-// src/document.ts
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-var documentTool = {
-  name: "document",
-  category: "Project",
-  description: "DEPRECATED \u2014 read-only preview stub that lists undocumented symbols as `skipped` candidates. It never writes files and does not generate real docstrings. If the auto-doc plugin is enabled, use its `auto_doc` tool (with `dry_run: true` to preview) instead.",
-  usageHint: "Deprecated: this tool only lists undocumented symbols with placeholder comments \u2014 it does not generate real JSDoc/TSDoc and writes nothing. When the auto-doc plugin is enabled, prefer its `auto_doc` tool (`dry_run: true` for previewing, without it for writing).",
-  permission: "auto",
-  mutating: false,
-  timeoutMs: 3e4,
-  capabilities: ["fs.read"],
-  icon: "document",
-  inputSchema: {
-    type: "object",
-    properties: {
-      target: {
-        type: "string",
-        enum: ["file", "function", "class", "type", "all"],
-        description: "What to document"
-      },
-      path: {
-        type: "string",
-        description: "Specific file path to document"
-      },
-      files: {
-        oneOf: [
-          { type: "string" },
-          { type: "array", items: { type: "string" } }
-        ],
-        description: "File(s) to process: single path, comma-separated list, or glob"
-      },
-      style: {
-        type: "string",
-        enum: ["jsdoc", "tsdoc", "block"],
-        description: "Documentation style (default: jsdoc)"
-      },
-      cwd: { type: "string", description: "Working directory (default: cwd)" }
-    }
-  },
-  async execute(input, ctx, _opts) {
-    const signal = _opts?.signal ?? ctx?.signal;
-    signal?.throwIfAborted();
-    const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
-    const style = input.style ?? "jsdoc";
-    const results = [];
-    let filesProcessed = 0;
-    let itemsDocumented = 0;
-    const fileList = input.files ? await resolveFiles(
-      Array.isArray(input.files) ? input.files.join(",") : input.files,
-      cwd,
-      ctx
-    ) : input.path ? [await safeResolveReal(input.path, ctx)] : [];
-    for (const absPath of fileList) {
-      if (signal?.aborted) break;
-      try {
-        const content = await fs.readFile(absPath, "utf8");
-        filesProcessed++;
-        const processed = processFile(
-          content,
-          absPath,
-          style,
-          input.overwrite ?? false,
-          input.target ?? "all"
-        );
-        results.push(...processed);
-        itemsDocumented += processed.filter((r) => r.status === "documented").length;
-      } catch (e) {
-        results.push({
-          path: absPath,
-          name: path.basename(absPath),
-          signature: "",
-          docstring: "",
-          status: "error",
-          error: e instanceof Error ? e.message : String(e)
-        });
-      }
-    }
-    return {
-      files_processed: filesProcessed,
-      items_documented: itemsDocumented,
-      results,
-      style
-    };
-  }
-};
-function getLineNumber(content, index) {
-  let line = 1;
-  for (let i = 0; i < index; i++) {
-    if (content.charCodeAt(i) === 10) line++;
-  }
-  return line;
-}
-async function resolveFiles(filesInput, cwd, ctx) {
-  const files = filesInput.split(",");
-  const resolved = [];
-  for (const f of files) {
-    const entry = f.trim();
-    if (!entry) continue;
-    let absPath;
-    try {
-      absPath = ensureInsideRoot(path.resolve(cwd, entry), ctx);
-    } catch {
-      continue;
-    }
-    try {
-      const stat2 = await fs.stat(absPath);
-      if (stat2.isFile()) resolved.push(absPath);
-    } catch {
-    }
-  }
-  return [...new Set(resolved)];
-}
-function processFile(content, absPath, _style, _overwrite, target) {
-  const results = [];
-  const functionRegex = /(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/g;
-  const arrowRegex = /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*=>/g;
-  const classRegex = /class\s+(\w+)/g;
-  const typeRegex = /(?:type|interface)\s+(\w+)\s*[=<]/g;
-  const allMatches = [];
-  if (target === "all" || target === "function") {
-    for (const m of content.matchAll(functionRegex)) {
-      if (!m[1]) continue;
-      allMatches.push({
-        name: m[1],
-        sig: m[2] ?? "",
-        type: "function",
-        line: getLineNumber(content, m.index)
-      });
-    }
-    for (const m of content.matchAll(arrowRegex)) {
-      if (!m[1]) continue;
-      allMatches.push({
-        name: m[1],
-        sig: m[2] ?? "",
-        type: "arrow",
-        line: getLineNumber(content, m.index)
-      });
-    }
-  }
-  if (target === "all" || target === "class") {
-    for (const m of content.matchAll(classRegex)) {
-      if (!m[1]) continue;
-      allMatches.push({
-        name: m[1],
-        sig: "",
-        type: "class",
-        line: getLineNumber(content, m.index)
-      });
-    }
-  }
-  if (target === "all" || target === "type") {
-    for (const m of content.matchAll(typeRegex)) {
-      if (!m[1]) continue;
-      allMatches.push({
-        name: m[1],
-        sig: m[0] ?? "",
-        type: "type",
-        line: getLineNumber(content, m.index)
-      });
-    }
-  }
-  for (const m of allMatches) {
-    results.push({
-      path: absPath,
-      name: m.name,
-      signature: m.sig,
-      docstring: `/** ${m.name} - documented at line ${m.line} */`,
-      status: "skipped"
-    });
-  }
-  return results;
-}
-
-export {
-  documentTool
-};
-//# sourceMappingURL=chunk-CHEK3ASV.js.map

package/dist/chunk-KLJZ4WV4.js

@@ -1,213 +0,0 @@
-import {
-  safeResolveReal
-} from "./chunk-ZUFHAHTE.js";
-
-// src/scaffold.ts
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { atomicWrite } from "@wrongstack/core/utils";
-var BUILT_IN_TEMPLATES = {
-  "npm-package": {
-    description: "Basic npm package with ESM",
-    files: {
-      "package.json": JSON.stringify(
-        {
-          name: "{{name}}",
-          version: "0.1.1",
-          type: "module",
-          main: "./dist/index.js",
-          scripts: { build: "tsc", test: "vitest run" },
-          devDependencies: { typescript: "^5.0.0" }
-        },
-        null,
-        2
-      ),
-      "tsconfig.json": JSON.stringify(
-        {
-          compilerOptions: { target: "ES2022", module: "ESNext", strict: true },
-          include: ["src"]
-        },
-        null,
-        2
-      ),
-      "src/index.ts": `export function hello() {
-  return 'Hello from {{name}}';
-}
-`,
-      "src/index.test.ts": `import { hello } from './index';
-import { describe, it, expect } from 'vitest';
-
-describe('hello', () => {
-  it('returns greeting', () => {
-    expect(hello()).toBe('Hello from {{name}}');
-  });
-});
-`
-    }
-  },
-  "cli-tool": {
-    description: "CLI tool with argparse",
-    files: {
-      "package.json": JSON.stringify(
-        {
-          name: "{{name}}",
-          version: "0.1.1",
-          type: "module",
-          bin: { "{{name}}": "./src/index.js" },
-          scripts: { build: "tsc", start: "node dist/index.js" }
-        },
-        null,
-        2
-      ),
-      "src/index.ts": `#!/usr/bin/env node
-
-async function main() {
-  console.log('Hello from {{name}}');
-}
-
-main();
-`
-    }
-  },
-  "react-component": {
-    description: "React component with TypeScript",
-    files: {
-      "{{name}}.tsx": `interface {{Name}}Props {
-  className?: string;
-}
-
-export function {{Name}}({ className }: {{Name}}Props) {
-  return (
-    <div className={className}>
-      {{Name}} Component
-    </div>
-  );
-}
-`,
-      "{{name}}.test.tsx": `import { render, screen } from '@testing-library/react';
-import { {{Name}} } from './{{Name}}';
-
-describe('{{Name}}', () => {
-  it('renders', () => {
-    render(<{{Name}} />);
-    expect(screen.getByText('{{Name}} Component')).toBeInTheDocument();
-  });
-});
-`
-    }
-  }
-};
-var scaffoldTool = {
-  name: "scaffold",
-  category: "Project",
-  description: "Generate or preview files and folder structures from built-in templates or custom definitions. Writes files to disk unless dry_run is set. This is the recommended way to bootstrap new packages, components, or modules instead of creating files one by one with `write`.",
-  usageHint: "PREFERRED FOR SCAFFOLDING:\n\n- Use built-in templates when they match your needs (e.g. react-component, npm-package).\n- Supports `dry_run` so you can preview exactly what will be created.\n- Has the powerful `fs.write.outside-project` capability \u2014 review paths carefully.\nMuch cleaner and safer than manually writing multiple files.",
-  permission: "confirm",
-  mutating: true,
-  subjectKey: "name",
-  capabilities: ["fs.write.outside-project", "fs.write"],
-  icon: "scaffold",
-  timeoutMs: 3e4,
-  inputSchema: {
-    type: "object",
-    properties: {
-      template: {
-        type: "string",
-        description: "Template name (npm-package, cli-tool, react-component) or path to template directory"
-      },
-      name: {
-        type: "string",
-        description: "Project/component name (used in generated files)"
-      },
-      cwd: { type: "string", description: "Working directory (default: cwd)" },
-      vars: {
-        type: "object",
-        additionalProperties: { type: "string" },
-        description: "Template variables for custom templates"
-      },
-      dry_run: {
-        type: "boolean",
-        description: "Preview generated files without creating (default: false)"
-      }
-    },
-    required: ["template", "name"]
-  },
-  async execute(input, ctx, _opts) {
-    const signal = _opts?.signal ?? ctx?.signal;
-    signal?.throwIfAborted();
-    const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
-    const name = input.name;
-    const vars = { name, ...input.vars };
-    const builtIn = BUILT_IN_TEMPLATES[input.template];
-    if (builtIn) {
-      return await handleBuiltIn(
-        name,
-        builtIn.files,
-        cwd,
-        ctx,
-        input.dry_run ?? false,
-        vars,
-        signal
-      );
-    }
-    return {
-      template: input.template,
-      name,
-      files_created: 0,
-      files: [],
-      dry_run: input.dry_run ?? false,
-      output: `Template "${input.template}" not found. Available: ${Object.keys(BUILT_IN_TEMPLATES).join(", ")}`
-    };
-  }
-};
-async function handleBuiltIn(name, templateFiles, cwd, ctx, dryRun, vars, signal) {
-  const files = [];
-  let filesCreated = 0;
-  for (const [filePath, content] of Object.entries(templateFiles)) {
-    if (signal?.aborted) break;
-    const resolvedPath = substituteVars(filePath, name, vars);
-    const joinedPath = path.join(cwd, resolvedPath);
-    const root = path.resolve(ctx.projectRoot ?? ctx.cwd ?? process.cwd());
-    const target = path.resolve(joinedPath);
-    const rel = path.relative(root, target);
-    if (rel.startsWith("..") || path.isAbsolute(rel)) {
-      throw new Error(`scaffold: generated path "${resolvedPath}" would escape project root`);
-    }
-    const fullPath = target;
-    if (!dryRun) {
-      await fs.mkdir(path.dirname(fullPath), { recursive: true });
-      await atomicWrite(fullPath, substituteVars(content, name, vars));
-    }
-    files.push(resolvedPath);
-    filesCreated++;
-  }
-  return {
-    template: "built-in",
-    name,
-    files_created: filesCreated,
-    files,
-    dry_run: dryRun,
-    output: dryRun ? `Would create ${filesCreated} files: ${files.join(", ")}` : `Created ${filesCreated} files: ${files.join(", ")}`
-  };
-}
-function escapeRegexLiteral(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function substituteVars(content, name, vars) {
-  const kebab = name.toLowerCase().replace(/\s+/g, "-");
-  const pascal = name.replace(/(?:^|[-_\s]+)([a-zA-Z])/g, (_, c) => c.toUpperCase());
-  let result = content;
-  result = result.replace(/\{\{name\}\}/g, () => kebab);
-  result = result.replace(/\{\{Name\}\}/g, () => pascal);
-  for (const [k, v] of Object.entries(vars)) {
-    if (k === "name" || k === "Name") continue;
-    result = result.replace(new RegExp(`\\{\\{${escapeRegexLiteral(k)}\\}\\}`, "g"), () => v);
-  }
-  return result;
-}
-
-export {
-  BUILT_IN_TEMPLATES,
-  scaffoldTool
-};
-//# sourceMappingURL=chunk-KLJZ4WV4.js.map

package/dist/chunk-VBF2YXUW.js

@@ -1,203 +0,0 @@
-// src/batch-tool-use.ts
-import {
-  GOVERNED_TOOL_EXECUTOR_META_KEY
-} from "@wrongstack/core/types";
-var BATCHABLE_TOOL_NAMES = [
-  "read",
-  "glob",
-  "grep",
-  "tree",
-  "codebase-stats",
-  "codebase-search",
-  "language_info",
-  "tool_search",
-  "memory_for_file",
-  "memory_for_path",
-  "memory_search"
-];
-var BATCHABLE_TOOLS = new Set(BATCHABLE_TOOL_NAMES);
-var MAX_BATCH_CALLS = 8;
-var MAX_PARALLEL_BATCH_CALLS = 3;
-var batchToolUseTool = {
-  name: "batch_tool_use",
-  category: "Meta",
-  description: "Execute a small batch of independent, read-only discovery calls. Process, mutation, browser-action, MCP, delegation, and nested meta tools are not eligible.",
-  usageHint: `BOUNDED READ-ONLY BATCHING:
-
-- Use only for a small set of independent reads or searches that are all needed now.
-- Do not wrap normal sequential reasoning or every tool call in a batch.
-- \`parallel: true\` (default) runs at most three eligible calls concurrently.
-- \`stop_on_error: true\` makes it fail fast on the first error.
-- Eligible tools: ${BATCHABLE_TOOL_NAMES.join(", ")}.`,
-  permission: "confirm",
-  // Scheduling barrier: keep the outer meta-call out of ToolExecutor's
-  // non-mutating fan-out even though every eligible inner tool is read-only.
-  mutating: true,
-  timeoutMs: 12e4,
-  capabilities: ["tool.meta"],
-  icon: "meta",
-  inputSchema: {
-    type: "object",
-    properties: {
-      calls: {
-        type: "array",
-        maxItems: MAX_BATCH_CALLS,
-        items: {
-          type: "object",
-          properties: {
-            tool: {
-              type: "string",
-              enum: [...BATCHABLE_TOOL_NAMES],
-              description: "An explicitly batch-safe, read-only discovery tool."
-            },
-            input: { type: "object" }
-          },
-          required: ["tool"]
-        },
-        description: `Up to ${MAX_BATCH_CALLS} independent, batch-safe read calls.`
-      },
-      stop_on_error: {
-        type: "boolean",
-        description: "Stop execution on first error (default: false)"
-      },
-      parallel: {
-        type: "boolean",
-        description: "Execute calls in parallel (default: true)"
-      }
-    },
-    required: ["calls"]
-  },
-  async execute(input, ctx, _opts) {
-    if (!input?.calls || input.calls.length === 0) {
-      return {
-        results: [],
-        total: 0,
-        succeeded: 0,
-        failed: 0,
-        stop_on_error: false
-      };
-    }
-    if (input.calls.length > MAX_BATCH_CALLS) {
-      throw new Error(`batch_tool_use: calls must contain at most ${MAX_BATCH_CALLS} items`);
-    }
-    const governedExecute = ctx.meta?.[GOVERNED_TOOL_EXECUTOR_META_KEY];
-    if (typeof governedExecute !== "function") {
-      return {
-        results: input.calls.map((call) => ({
-          tool: call.tool,
-          success: false,
-          error: "governed nested execution is unavailable; call the tool directly",
-          executionMs: 0
-        })),
-        total: input.calls.length,
-        succeeded: 0,
-        failed: input.calls.length,
-        stop_on_error: input.stop_on_error ?? false
-      };
-    }
-    const results = [];
-    let succeeded = 0;
-    let failed = 0;
-    if (input.parallel !== false) {
-      let stopRequested = false;
-      const allResults = await mapWithConcurrency(
-        input.calls,
-        MAX_PARALLEL_BATCH_CALLS,
-        async (call) => {
-          const result = await executeSingle(call, ctx, governedExecute);
-          if (input.stop_on_error && !result.success) stopRequested = true;
-          return result;
-        },
-        () => stopRequested
-      );
-      const executed = allResults.filter(
-        (r) => r !== void 0
-      );
-      results.push(...executed);
-      succeeded = executed.filter((r) => r.success).length;
-      failed = executed.filter((r) => !r.success).length;
-    } else {
-      for (const call of input.calls) {
-        const result = await executeSingle(call, ctx, governedExecute);
-        results.push(result);
-        if (result.success) {
-          succeeded++;
-        } else {
-          failed++;
-          if (input.stop_on_error) break;
-        }
-      }
-    }
-    return {
-      results,
-      total: input.calls.length,
-      succeeded,
-      failed,
-      stop_on_error: input.stop_on_error ?? false
-    };
-  }
-};
-async function mapWithConcurrency(items, limit, run, shouldStop) {
-  const results = new Array(items.length);
-  let nextIndex = 0;
-  const worker = async () => {
-    while (nextIndex < items.length) {
-      if (shouldStop?.()) return;
-      const index = nextIndex++;
-      results[index] = await run(items[index]);
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
-  return results;
-}
-async function executeSingle(call, ctx, governedExecute) {
-  const start = Date.now();
-  if (call.tool === batchToolUseTool.name) {
-    return {
-      tool: call.tool,
-      success: false,
-      error: "recursive batch_tool_use execution is not allowed",
-      executionMs: Date.now() - start
-    };
-  }
-  const tool = (ctx.catalogTools ?? ctx.tools).find(
-    (candidate) => candidate.name === call.tool
-  );
-  if (!tool) {
-    return {
-      tool: call.tool,
-      success: false,
-      error: `tool "${call.tool}" not found`,
-      executionMs: Date.now() - start
-    };
-  }
-  if (!BATCHABLE_TOOLS.has(tool.name) || tool.mutating) {
-    return {
-      tool: call.tool,
-      success: false,
-      error: `tool "${call.tool}" is not eligible for batch execution; call it directly. Allowed: ${BATCHABLE_TOOL_NAMES.join(", ")}`,
-      executionMs: Date.now() - start
-    };
-  }
-  try {
-    const result = await governedExecute(call.tool, call.input);
-    return {
-      tool: call.tool,
-      success: result.success,
-      ...result.success ? { result: result.result } : { error: result.error ?? "nested tool failed" },
-      executionMs: Date.now() - start
-    };
-  } catch (e) {
-    return {
-      tool: call.tool,
-      success: false,
-      error: e instanceof Error ? e.message : String(e),
-      executionMs: Date.now() - start
-    };
-  }
-}
-
-export {
-  batchToolUseTool
-};
-//# sourceMappingURL=chunk-VBF2YXUW.js.map

package/dist/document.d.ts

@@ -1,25 +0,0 @@
-import type { Tool } from '@wrongstack/core/types';
-export interface DocumentInput {
-    target: 'file' | 'function' | 'class' | 'type' | 'all';
-    path?: string | undefined;
-    files?: string | string[] | undefined;
-    style?: 'jsdoc' | 'tsdoc' | 'block' | undefined;
-    overwrite?: boolean | undefined;
-    cwd?: string | undefined;
-}
-export interface DocumentedItem {
-    path: string;
-    name: string;
-    signature: string;
-    docstring: string;
-    status: 'documented' | 'skipped' | 'error';
-    error?: string | undefined;
-}
-export interface DocumentOutput {
-    files_processed: number;
-    items_documented: number;
-    results: DocumentedItem[];
-    style: string;
-}
-export declare const documentTool: Tool<DocumentInput, DocumentOutput>;
-//# sourceMappingURL=document.d.ts.map

package/dist/document.js

@@ -1,8 +0,0 @@
-import {
-  documentTool
-} from "./chunk-CHEK3ASV.js";
-import "./chunk-ZUFHAHTE.js";
-export {
-  documentTool
-};
-//# sourceMappingURL=document.js.map

package/dist/scaffold.d.ts

@@ -1,23 +0,0 @@
-import type { Tool } from '@wrongstack/core/types';
-export interface ScaffoldInput {
-    template: string;
-    name: string;
-    cwd?: string | undefined;
-    vars?: Record<string, string>;
-    dry_run?: boolean | undefined;
-}
-export interface ScaffoldOutput {
-    template: string;
-    name: string;
-    files_created: number;
-    files: string[];
-    dry_run: boolean;
-    output: string;
-}
-export interface ScaffoldTemplate {
-    description: string;
-    files: Record<string, string>;
-}
-export declare const BUILT_IN_TEMPLATES: Record<string, ScaffoldTemplate>;
-export declare const scaffoldTool: Tool<ScaffoldInput, ScaffoldOutput>;
-//# sourceMappingURL=scaffold.d.ts.map

package/dist/scaffold.js

@@ -1,10 +0,0 @@
-import {
-  BUILT_IN_TEMPLATES,
-  scaffoldTool
-} from "./chunk-KLJZ4WV4.js";
-import "./chunk-ZUFHAHTE.js";
-export {
-  BUILT_IN_TEMPLATES,
-  scaffoldTool
-};
-//# sourceMappingURL=scaffold.js.map

package/dist/set-working-dir.d.ts

@@ -1,17 +0,0 @@
-import type { Tool } from '@wrongstack/core/types';
-export interface SetWorkingDirInput {
-    /** Relative or absolute path to navigate to. Must stay within projectRoot. */
-    path?: string | undefined;
-}
-export interface SetWorkingDirOutput {
-    /** The new working directory (absolute path). */
-    current: string;
-    /** The previous working directory (absolute path). */
-    previous?: string | undefined;
-    /** Human-readable confirmation message. */
-    message?: string | undefined;
-    /** Error if the directory doesn't exist or is outside the project root. */
-    error?: string | undefined;
-}
-export declare const setWorkingDirTool: Tool<SetWorkingDirInput, SetWorkingDirOutput>;
-//# sourceMappingURL=set-working-dir.d.ts.map