@wrongstack/tools 0.313.0 → 0.313.1

package/dist/chunk-A6BRWIXN.js

@@ -0,0 +1,317 @@
+// src/codebase-index/generic-parser.ts
+var C_LIKE = [
+  { re: /\b(?:class|struct|enum|interface|union)\s+([A-Za-z_]\w*)/g, kind: "class" },
+  {
+    re: /\b(?:public|private|protected|static|final|async|override|virtual|inline|export)?\s*(?:[\w:<>[\]\s*&]+)\s+([A-Za-z_]\w*)\s*\([^;{]*\)\s*(?:const)?\s*[{;]/g,
+    kind: "function"
+  },
+  { re: /\b(?:namespace)\s+([A-Za-z_]\w*)/g, kind: "namespace" }
+];
+var LANG_PATTERNS = {
+  py: [
+    { re: /^(?:async\s+)?def\s+([A-Za-z_]\w*)/gm, kind: "function" },
+    { re: /^class\s+([A-Za-z_]\w*)/gm, kind: "class" },
+    { re: /^([A-Za-z_]\w*)\s*=/gm, kind: "var" }
+  ],
+  go: [
+    { re: /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*\(/gm, kind: "function" },
+    { re: /^type\s+([A-Za-z_]\w*)\b/gm, kind: "type" },
+    { re: /^(?:const|var)\s+([A-Za-z_]\w*)\b/gm, kind: "const" },
+    { re: /^package\s+([A-Za-z_]\w*)/gm, kind: "namespace" }
+  ],
+  rs: [
+    { re: /\bfn\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /\bstruct\s+([A-Za-z_]\w*)/g, kind: "struct" },
+    { re: /\benum\s+([A-Za-z_]\w*)/g, kind: "enum" },
+    { re: /\btrait\s+([A-Za-z_]\w*)/g, kind: "trait" },
+    { re: /\bimpl(?:\s*<[^>]+>)?\s+([A-Za-z_]\w*)/g, kind: "impl" },
+    { re: /\b(?:const|static)\s+([A-Za-z_]\w*)/g, kind: "const" },
+    { re: /\bmod\s+([A-Za-z_]\w*)/g, kind: "mod" }
+  ],
+  c: C_LIKE,
+  cpp: C_LIKE,
+  java: [
+    { re: /\b(?:class|interface|enum|record)\s+([A-Za-z_]\w*)/g, kind: "class" },
+    {
+      re: /\b(?:public|private|protected|static|final|abstract|synchronized|native|default|\s)+\s*[\w.<>,[\]\s]+\s+([A-Za-z_]\w*)\s*\(/g,
+      kind: "method"
+    }
+  ],
+  csharp: [
+    { re: /\b(?:class|interface|struct|enum|record)\s+([A-Za-z_]\w*)/g, kind: "class" },
+    { re: /\bnamespace\s+([A-Za-z_.\w]+)/g, kind: "namespace" },
+    {
+      re: /\b(?:public|private|protected|internal|static|async|override|virtual|\s)+\s*[\w.<>,[\]\s]+\s+([A-Za-z_]\w*)\s*\(/g,
+      kind: "method"
+    }
+  ],
+  php: [
+    { re: /\bfunction\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /\bclass\s+([A-Za-z_]\w*)/g, kind: "class" },
+    { re: /\binterface\s+([A-Za-z_]\w*)/g, kind: "interface" },
+    { re: /\bnamespace\s+([A-Za-z_\\]+)/g, kind: "namespace" }
+  ],
+  ruby: [
+    { re: /^\s*def\s+(?:self\.)?([A-Za-z_]\w*[!?]?)/gm, kind: "function" },
+    { re: /^\s*class\s+([A-Za-z_]\w*)/gm, kind: "class" },
+    { re: /^\s*module\s+([A-Za-z_]\w*)/gm, kind: "namespace" }
+  ],
+  swift: [
+    { re: /\b(?:func)\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /\b(?:class|struct|enum|protocol|actor)\s+([A-Za-z_]\w*)/g, kind: "class" }
+  ],
+  kotlin: [
+    { re: /\b(?:fun)\s+([A-Za-z_]\w*)/g, kind: "function" },
+    {
+      re: /\b(?:class|interface|object|enum\s+class|data\s+class)\s+([A-Za-z_]\w*)/g,
+      kind: "class"
+    }
+  ],
+  scala: [
+    { re: /\b(?:def)\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /\b(?:class|object|trait|enum)\s+([A-Za-z_]\w*)/g, kind: "class" }
+  ],
+  shell: [
+    { re: /^(?:function\s+)?([A-Za-z_]\w*)\s*\(\)\s*\{/gm, kind: "function" },
+    { re: /^([A-Za-z_][\w]*)\s*\(\)\s*\{/gm, kind: "function" }
+  ],
+  sql: [
+    {
+      re: /\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:TABLE|VIEW|INDEX|FUNCTION|PROCEDURE|TRIGGER)\s+(?:IF\s+NOT\s+EXISTS\s+)?([A-Za-z_"][\w."]*)/gi,
+      kind: "type"
+    }
+  ],
+  md: [{ re: /^(#{1,6})\s+(.+)$/gm, kind: "namespace" }],
+  toml: [{ re: /^\[([^\]]+)\]/gm, kind: "namespace" }],
+  html: [
+    { re: /\bid\s*=\s*["']([^"']+)["']/gi, kind: "property" },
+    { re: /<(?:script|template|style)\b/gi, kind: "namespace" }
+  ],
+  css: [
+    { re: /^\s*([.#]?[A-Za-z_][\w-]*)\s*\{/gm, kind: "type" },
+    { re: /@(?:keyframes|media|supports)\s+([^{\s]+)/g, kind: "namespace" }
+  ],
+  vue: [
+    {
+      re: /\b(?:function|const|let|var|class|export\s+(?:default\s+)?(?:function|class|const))\s+([A-Za-z_]\w*)/g,
+      kind: "function"
+    },
+    { re: /<(?:script|template|style)\b/gi, kind: "namespace" }
+  ],
+  svelte: [
+    {
+      re: /\b(?:function|const|let|var|class|export\s+(?:default\s+)?(?:function|class|const))\s+([A-Za-z_]\w*)/g,
+      kind: "function"
+    }
+  ],
+  dart: [
+    { re: /\b(?:class|enum|mixin|extension)\s+([A-Za-z_]\w*)/g, kind: "class" },
+    { re: /\b([A-Za-z_]\w*)\s*\([^;]*\)\s*(?:async\s*)?\{/g, kind: "function" }
+  ],
+  lua: [
+    { re: /\bfunction\s+([A-Za-z_.:]\w*)/g, kind: "function" },
+    { re: /\blocal\s+function\s+([A-Za-z_]\w*)/g, kind: "function" }
+  ],
+  r: [
+    { re: /([A-Za-z.]\w*)\s*<-\s*function\s*\(/g, kind: "function" },
+    { re: /([A-Za-z.]\w*)\s*=\s*function\s*\(/g, kind: "function" }
+  ],
+  proto: [
+    { re: /\b(?:message|service|enum)\s+([A-Za-z_]\w*)/g, kind: "type" },
+    { re: /\brpc\s+([A-Za-z_]\w*)/g, kind: "function" }
+  ],
+  graphql: [
+    { re: /\b(?:type|interface|enum|input|union|scalar)\s+([A-Za-z_]\w*)/g, kind: "type" },
+    { re: /\b(?:query|mutation|subscription)\s+([A-Za-z_]\w*)/g, kind: "function" }
+  ],
+  zig: [
+    { re: /\b(?:fn|pub\s+fn)\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /\b(?:const|var)\s+([A-Za-z_]\w*)/g, kind: "const" },
+    { re: /\b(?:struct|enum|union)\s*\{/g, kind: "type" }
+  ],
+  elixir: [
+    { re: /\bdef(?:p|macro|macrop)?\s+([A-Za-z_]\w*[!?]?)/g, kind: "function" },
+    // Dotted module names must be captured whole: `alias Foo.Bar` resolves
+    // against this symbol, and a `Foo`-only capture never matches it.
+    { re: /\bdefmodule\s+([A-Z][\w.]*)/g, kind: "namespace" }
+  ],
+  haskell: [
+    // Target of `import Data.List`.
+    { re: /^module\s+([A-Z][\w.]*)/gm, kind: "namespace" },
+    { re: /^([A-Za-z_]\w*)\s*::/gm, kind: "function" },
+    { re: /\bdata\s+([A-Za-z_]\w*)/g, kind: "type" },
+    { re: /\btype\s+(?:family\s+)?([A-Za-z_]\w*)/g, kind: "type" },
+    { re: /\bclass\s+([A-Za-z_]\w*)/g, kind: "class" }
+  ],
+  other: [
+    { re: /^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_]\w*)/gm, kind: "function" },
+    { re: /^(?:export\s+)?class\s+([A-Za-z_]\w*)/gm, kind: "class" },
+    { re: /^(?:export\s+)?(?:const|let|var)\s+([A-Za-z_]\w*)/gm, kind: "const" },
+    { re: /^(?:async\s+)?def\s+([A-Za-z_]\w*)/gm, kind: "function" },
+    { re: /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)/gm, kind: "function" },
+    { re: /\bfn\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /^(?:target|PHONY)\s*:/gm, kind: "namespace" }
+  ]
+};
+var KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "else",
+  "for",
+  "while",
+  "switch",
+  "case",
+  "return",
+  "break",
+  "continue",
+  "new",
+  "delete",
+  "typeof",
+  "instanceof",
+  "void",
+  "null",
+  "true",
+  "false",
+  "this",
+  "super",
+  "import",
+  "export",
+  "from",
+  "as",
+  "default",
+  "public",
+  "private",
+  "protected",
+  "static",
+  "final",
+  "class",
+  "struct",
+  "enum",
+  "interface",
+  "function",
+  "def",
+  "fn",
+  "func",
+  "var",
+  "let",
+  "const",
+  "package",
+  "namespace",
+  "module",
+  "using",
+  "include",
+  "require",
+  "select",
+  "from",
+  "where",
+  "and",
+  "or",
+  "not",
+  "in",
+  "is",
+  "try",
+  "catch",
+  "finally",
+  "throw",
+  "async",
+  "await",
+  "yield"
+]);
+function patternsFor(lang) {
+  return LANG_PATTERNS[lang] ?? LANG_PATTERNS.other ?? [];
+}
+function looksBinary(content) {
+  if (content.includes("\0")) return true;
+  const sample = content.slice(0, 2048);
+  if (sample.length === 0) return false;
+  let bad = 0;
+  for (let i = 0; i < sample.length; i++) {
+    const c = sample.charCodeAt(i);
+    if (c === 9 || c === 10 || c === 13) continue;
+    if (c < 32 || c === 127) bad++;
+  }
+  return bad / sample.length > 0.1;
+}
+function newlineOffsets(content) {
+  const offsets = [];
+  for (let i = 0; i < content.length; i++) {
+    if (content.charCodeAt(i) === 10) offsets.push(i);
+  }
+  return offsets;
+}
+function lineColAt(offsets, index) {
+  let low = 0;
+  let high = offsets.length;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    if ((offsets[mid] ?? 0) < index) low = mid + 1;
+    else high = mid;
+  }
+  const lastNl = low > 0 ? offsets[low - 1] : -1;
+  return { line: low + 1, col: index - lastNl };
+}
+var GENERIC_MAX_SYMBOLS_DEFAULT = 500;
+var GENERIC_MAX_FILE_CHARS = 512 * 1024;
+function parseGeneric(opts) {
+  const { file, lang } = opts;
+  const maxSymbols = opts.maxSymbols ?? GENERIC_MAX_SYMBOLS_DEFAULT;
+  const mtimeMs = Date.now();
+  if (!opts.content || looksBinary(opts.content)) {
+    return { file, lang, symbols: [], mtimeMs };
+  }
+  const content = opts.content.length > GENERIC_MAX_FILE_CHARS ? opts.content.slice(0, GENERIC_MAX_FILE_CHARS) : opts.content;
+  const patterns = patternsFor(lang);
+  const symbols = [];
+  const seen = /* @__PURE__ */ new Set();
+  const nlOffsets = newlineOffsets(content);
+  for (const pattern of patterns) {
+    const re = new RegExp(
+      pattern.re.source,
+      pattern.re.flags.includes("g") ? pattern.re.flags : `${pattern.re.flags}g`
+    );
+    re.lastIndex = 0;
+    for (const match of content.matchAll(re)) {
+      if (symbols.length >= maxSymbols) break;
+      let name = (match[1] ?? match[2] ?? "").trim();
+      if (lang === "md" && match[2]) name = match[2].trim();
+      if (!name || name.length > 200) continue;
+      name = name.replace(/^#+\s*/, "").replace(/["'`]/g, "");
+      if (!name || KEYWORDS.has(name.toLowerCase())) continue;
+      if (!/^[A-Za-z_#.@/\w][\w.\-:/#!?]*$/.test(name) && lang !== "md" && lang !== "toml") {
+        continue;
+      }
+      const { line, col } = lineColAt(nlOffsets, match.index ?? 0);
+      const key = `${name}\0${line}\0${pattern.kind}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const nl = content.indexOf("\n", match.index);
+      const lineText = content.slice(match.index, nl === -1 ? content.length : nl);
+      const signature = (lineText || name).trim().slice(0, 500);
+      symbols.push({
+        id: 0,
+        lang,
+        kind: lang === "md" ? "namespace" : pattern.kind,
+        name: name.slice(0, 200),
+        file,
+        line,
+        col,
+        signature,
+        docComment: "",
+        scope: "",
+        text: `${name} ${signature}`.trim().slice(0, 1e3)
+      });
+    }
+    if (symbols.length >= maxSymbols) break;
+  }
+  return { file, lang, symbols, mtimeMs };
+}
+async function parseSymbols(opts) {
+  return parseGeneric(opts);
+}
+
+export {
+  GENERIC_MAX_SYMBOLS_DEFAULT,
+  GENERIC_MAX_FILE_CHARS,
+  parseGeneric,
+  parseSymbols
+};
+//# sourceMappingURL=chunk-A6BRWIXN.js.map

package/dist/chunk-AHHDWNXC.js

@@ -0,0 +1,200 @@
+import {
+  safeResolveReal
+} from "./chunk-D33S4RQG.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 new files and folder structures from built-in templates or custom definitions. 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) {
+    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);
+    }
+    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) {
+  const files = [];
+  let filesCreated = 0;
+  for (const [filePath, content] of Object.entries(templateFiles)) {
+    const resolvedPath = substituteVars(filePath, name, vars);
+    const joinedPath = path.join(cwd, resolvedPath);
+    const root = path.resolve(ctx.projectRoot);
+    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-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)) {
+    result = result.replace(new RegExp(`\\{\\{${escapeRegexLiteral(k)}\\}\\}`, "g"), () => v);
+  }
+  return result;
+}
+
+export {
+  scaffoldTool
+};
+//# sourceMappingURL=chunk-AHHDWNXC.js.map