@wrongstack/tools 0.313.0 → 0.316.1

package/dist/rs-parser-XHUUO2KZ.js

@@ -0,0 +1,81 @@
+import {
+  detectLang
+} from "./chunk-TEBQ4VPZ.js";
+
+// src/codebase-index/rs-parser.ts
+import { expectDefined } from "@wrongstack/core/utils";
+async function parseSymbols(opts) {
+  const { file, content, lang } = opts;
+  return regexParse({ file, content, lang });
+}
+var RS_PATTERNS = [
+  { regex: /fn\s+(\w+)\s*\([^)]*\)/g, kind: "function" },
+  { regex: /struct\s+(\w+)/g, kind: "struct" },
+  { regex: /enum\s+(\w+)/g, kind: "enum" },
+  { regex: /trait\s+(\w+)/g, kind: "trait" },
+  { regex: /impl\s+(?:<[^>]+>)?(\w+)/g, kind: "impl" },
+  { regex: /type\s+(\w+)\s*=/g, kind: "type" },
+  { regex: /const\s+(\w+)/g, kind: "const" },
+  { regex: /static\s+(\w+)/g, kind: "static" },
+  { regex: /mod\s+(\w+)/g, kind: "mod" }
+];
+function regexParse(opts) {
+  const { file, content, lang } = opts;
+  const symbols = [];
+  const lines = content.split("\n");
+  const lineOffsets = [0];
+  for (let i = 0; i < lines.length; i++) {
+    lineOffsets.push((lineOffsets[i] ?? 0) + (lines[i]?.length ?? 0) + 1);
+  }
+  function lineFromOffset(offset) {
+    let lo = 0;
+    let hi = lineOffsets.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (expectDefined(lineOffsets[mid]) <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo + 1;
+  }
+  function extractDeclaration(lineIdx, _match) {
+    const line = lines[lineIdx] ?? "";
+    return line.trim().slice(0, 500);
+  }
+  for (const pattern of RS_PATTERNS) {
+    pattern.regex.lastIndex = 0;
+    for (let match = pattern.regex.exec(content); match !== null; match = pattern.regex.exec(content)) {
+      const name = expectDefined(match[1]);
+      const offset = match.index ?? 0;
+      const line = lineFromOffset(offset);
+      const col = offset - (lineOffsets[line - 1] ?? 0);
+      const lineIdx = line - 1;
+      const signature = extractDeclaration(lineIdx, match);
+      symbols.push({
+        id: 0,
+        lang,
+        kind: pattern.kind,
+        name,
+        file,
+        line,
+        col,
+        signature,
+        docComment: "",
+        scope: "",
+        text: `${name} ${signature}`.trim()
+      });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = symbols.filter((s) => {
+    const key = `${s.name}:${s.line}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  return { file, lang, symbols: deduped, mtimeMs: Date.now() };
+}
+export {
+  detectLang,
+  parseSymbols
+};
+//# sourceMappingURL=rs-parser-XHUUO2KZ.js.map

package/dist/scaffold.js

@@ -1,256 +1,7 @@
-// src/scaffold.ts
-import * as fs from "node:fs/promises";
-import * as path2 from "node:path";
-import { atomicWrite } from "@wrongstack/core/utils";
-
-// 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/scaffold.ts
-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 = path2.join(cwd, resolvedPath);
-    const root = path2.resolve(ctx.projectRoot);
-    const target = path2.resolve(joinedPath);
-    const rel = path2.relative(root, target);
-    if (rel.startsWith("..") || path2.isAbsolute(rel)) {
-      throw new Error(`scaffold: generated path "${resolvedPath}" would escape project root`);
-    }
-    const fullPath = target;
-    if (!dryRun) {
-      await fs.mkdir(path2.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;
-}
+import {
+  scaffoldTool
+} from "./chunk-AHHDWNXC.js";
+import "./chunk-D33S4RQG.js";
 export {
   scaffoldTool
 };