@esneiderbravo/speclaw 0.3.11 → 0.3.13

package/dist/modules/lawbook/stack-parse.js

@@ -0,0 +1,135 @@
+import path from "node:path";
+const V8_NAMED = /^\s*at\s+(?:async\s+)?(?:(.+?)\s+\()?([^\s()]+):(\d+):(\d+)\)?\s*$/;
+const V8_ANON = /^\s*at\s+([^\s()]+):(\d+):(\d+)\s*$/;
+const PY_FRAME = /^\s*File\s+"([^"]+)",\s*line\s+(\d+)(?:,\s*in\s+(.+))?\s*$/;
+function isExternal(rawPath) {
+    const n = rawPath.replace(/\\/g, "/");
+    return (n.includes("node_modules/") ||
+        n.includes("node:internal") ||
+        n.startsWith("node:") ||
+        n.includes("/lib/python") ||
+        n.includes("site-packages/"));
+}
+/**
+ * Map `dist/foo.js` → `src/foo.ts` when the basename matches (no silent guess
+ * beyond that convention).
+ */
+export function mapDistToSrc(rel) {
+    const n = rel.replace(/\\/g, "/");
+    if (!n.startsWith("dist/"))
+        return n;
+    const base = path.basename(n, path.extname(n));
+    return `src/${base}.ts`;
+}
+/**
+ * Normalize an absolute or relative trace path to a project-relative path.
+ *
+ * @param projectPath - Project root used to strip prefixes.
+ * @param rawPath - Path as it appears in the trace.
+ */
+export function normalizeTracePath(projectPath, rawPath) {
+    let p = rawPath.replace(/\\/g, "/");
+    const root = projectPath.replace(/\\/g, "/");
+    if (p.startsWith(root + "/"))
+        p = p.slice(root.length + 1);
+    if (p.startsWith("file://")) {
+        try {
+            p = decodeURIComponent(new URL(p).pathname);
+            if (p.startsWith(root + "/"))
+                p = p.slice(root.length + 1);
+        }
+        catch {
+            /* keep raw */
+        }
+    }
+    p = p.replace(/^\.\//, "");
+    p = mapDistToSrc(p);
+    return p;
+}
+function parseV8Line(line, projectPath) {
+    const named = V8_NAMED.exec(line);
+    if (named) {
+        const rawPath = named[2];
+        if (isExternal(rawPath))
+            return { raw: line.trim(), reason: "external" };
+        const fn = named[1]?.trim() ?? "";
+        const file = normalizeTracePath(projectPath, rawPath);
+        return { fn, file, line: Number(named[3]), rawPath };
+    }
+    const anon = V8_ANON.exec(line);
+    if (anon) {
+        const rawPath = anon[1];
+        if (isExternal(rawPath))
+            return { raw: line.trim(), reason: "external" };
+        return {
+            fn: "",
+            file: normalizeTracePath(projectPath, rawPath),
+            line: Number(anon[2]),
+            rawPath,
+        };
+    }
+    return null;
+}
+function parsePythonLines(lines, projectPath) {
+    const pyFrames = [];
+    const unresolved = [];
+    for (const line of lines) {
+        const m = PY_FRAME.exec(line);
+        if (!m)
+            continue;
+        const rawPath = m[1];
+        if (isExternal(rawPath)) {
+            unresolved.push({ raw: line.trim(), reason: "external" });
+            continue;
+        }
+        pyFrames.push({
+            fn: m[3]?.trim() ?? "",
+            file: normalizeTracePath(projectPath, rawPath),
+            line: Number(m[2]),
+            rawPath,
+        });
+    }
+    // Python traces list shallow→deep; invert to deepest-first like V8.
+    pyFrames.reverse();
+    return { frames: pyFrames, unresolved, format: "python" };
+}
+/**
+ * Parse a V8 (Node) or Python stack trace into own-project frames.
+ *
+ * @param projectPath - Project root for path normalization.
+ * @param stackTrace - Raw stack trace text.
+ */
+export function parseStackTrace(projectPath, stackTrace) {
+    const lines = stackTrace.split("\n");
+    const pyProbe = lines.some((l) => PY_FRAME.test(l));
+    if (pyProbe)
+        return parsePythonLines(lines, projectPath);
+    const frames = [];
+    const unresolved = [];
+    let sawV8 = false;
+    for (const line of lines) {
+        const parsed = parseV8Line(line, projectPath);
+        if (!parsed)
+            continue;
+        sawV8 = true;
+        if ("reason" in parsed)
+            unresolved.push(parsed);
+        else
+            frames.push(parsed);
+    }
+    if (!sawV8 && stackTrace.trim()) {
+        for (const line of lines) {
+            if (line.trim())
+                unresolved.push({ raw: line.trim(), reason: "unparseable" });
+        }
+        return { frames: [], unresolved, format: "unknown" };
+    }
+    return { frames, unresolved, format: "v8" };
+}
+/** Extract a simple method name from `Class.method` frames. */
+export function frameSymbolName(frame) {
+    if (!frame.fn)
+        return "";
+    const dot = frame.fn.lastIndexOf(".");
+    return dot >= 0 ? frame.fn.slice(dot + 1) : frame.fn;
+}

package/dist/shared/exposure.js

@@ -19,6 +19,8 @@ export const MINIMAL_OMIT = new Set([
     "lawbook_init",
     "lawbook_archive",
     "lawbook_list",
+    "lawbook_level",
+    "lawbook_investigate",
     "init_project",
     "scaffold",
     "configure_agent",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esneiderbravo/speclaw",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "publishConfig": {
     "access": "public"
   },