@epoch-ai/cli 2.2.4

package/test/util/lock.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from "bun:test"
+import { Lock } from "../../src/util/lock"
+
+function tick() {
+  return new Promise<void>((r) => queueMicrotask(r))
+}
+
+async function flush(n = 5) {
+  for (let i = 0; i < n; i++) await tick()
+}
+
+describe("util.lock", () => {
+  test("writer exclusivity: blocks reads and other writes while held", async () => {
+    const key = "lock:" + Math.random().toString(36).slice(2)
+
+    const state = {
+      writer2: false,
+      reader: false,
+      writers: 0,
+    }
+
+    // Acquire writer1
+    using writer1 = await Lock.write(key)
+    state.writers++
+    expect(state.writers).toBe(1)
+
+    // Start writer2 candidate (should block)
+    const writer2Task = (async () => {
+      const w = await Lock.write(key)
+      state.writers++
+      expect(state.writers).toBe(1)
+      state.writer2 = true
+      // Hold for a tick so reader cannot slip in
+      await tick()
+      return w
+    })()
+
+    // Start reader candidate (should block)
+    const readerTask = (async () => {
+      const r = await Lock.read(key)
+      state.reader = true
+      return r
+    })()
+
+    // Flush microtasks and assert neither acquired
+    await flush()
+    expect(state.writer2).toBe(false)
+    expect(state.reader).toBe(false)
+
+    // Release writer1
+    writer1[Symbol.dispose]()
+    state.writers--
+
+    // writer2 should acquire next
+    const writer2 = await writer2Task
+    expect(state.writer2).toBe(true)
+
+    // Reader still blocked while writer2 held
+    await flush()
+    expect(state.reader).toBe(false)
+
+    // Release writer2
+    writer2[Symbol.dispose]()
+    state.writers--
+
+    // Reader should now acquire
+    const reader = await readerTask
+    expect(state.reader).toBe(true)
+
+    reader[Symbol.dispose]()
+  })
+})

package/test/util/log-parser.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, afterAll, beforeAll } from "bun:test"
+import * as fs from "fs/promises"
+import * as path from "path"
+import { LogParserTool } from "../../src/util/log-parser"
+
+describe("LogParserTool - State Machine Overlap Detection", () => {
+  const tmpDir = path.join(process.cwd(), "test-logs-tmp")
+
+  beforeAll(async () => {
+    await fs.mkdir(tmpDir, { recursive: true })
+  })
+
+  afterAll(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true })
+  })
+
+  it("validates successful sequential execution", async () => {
+    const logPath = path.join(tmpDir, "valid.log")
+    const logContent = `
+2026-04-08T12:00:00 INFO {"mainEpochId":"123","event":"START_GENERATE","providerId":"local-side","phase":"Phase 1"}
+2026-04-08T12:00:01 INFO {"mainEpochId":"123","event":"END_GENERATE","providerId":"local-side","phase":"Phase 1","metrics":{"metrics":{"json_repaired":true}}}
+2026-04-08T12:00:02 INFO {"mainEpochId":"123","event":"START_GENERATE","providerId":"local-main","phase":"Phase 2"}
+2026-04-08T12:00:05 INFO {"mainEpochId":"123","event":"END_GENERATE","providerId":"local-main","phase":"Phase 2"}
+`
+    await fs.writeFile(logPath, logContent.trim())
+
+    const result = await LogParserTool.verifySequentialExecution(logPath)
+    expect(result.valid).toBe(true)
+    expect(result.message).toContain("Total sequential handoffs: 2")
+    expect(result.message).toContain("JSON Repairs: 1")
+  })
+
+  it("flags overlapping execution when local-main starts while local-side is active", async () => {
+    const logPath = path.join(tmpDir, "overlap.log")
+    const logContent = `
+2026-04-08T12:00:00 INFO {"mainEpochId":"456","event":"START_GENERATE","providerId":"local-side","phase":"Phase 1"}
+2026-04-08T12:00:01 INFO {"mainEpochId":"456","event":"START_GENERATE","providerId":"local-main","phase":"Phase 2"}
+`
+    await fs.writeFile(logPath, logContent.trim())
+
+    const result = await LogParserTool.verifySequentialExecution(logPath)
+    expect(result.valid).toBe(false)
+    expect(result.message).toContain(
+      "Concurrency Violation: local-main started while local-side was still active in epoch 456",
+    )
+  })
+
+  it("ignores malformed JSON and skips gracefully", async () => {
+    const logPath = path.join(tmpDir, "malformed.log")
+    const logContent = `
+2026-04-08T12:00:00 INFO {"mainEpochId":"789","event":"START_GENERATE","providerId":"local-side","phase":"Phase 1"}
+Just a normal log line with { some invalid JSON
+2026-04-08T12:00:01 INFO {"mainEpochId":"789","event":"END_GENERATE","providerId":"local-side","phase":"Phase 1"}
+`
+    await fs.writeFile(logPath, logContent.trim())
+
+    const result = await LogParserTool.verifySequentialExecution(logPath)
+    expect(result.valid).toBe(true)
+    expect(result.message).toContain("Total sequential handoffs: 1")
+  })
+})

package/test/util/module.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test"
+import path from "path"
+import { Module } from "@epoch-ai/util/module"
+import { Filesystem } from "../../src/util/filesystem"
+import { tmpdir } from "../fixture/fixture"
+
+describe("util.module", () => {
+  test("resolves package subpaths from the provided dir", async () => {
+    await using tmp = await tmpdir()
+    const root = path.join(tmp.path, "proj")
+    const file = path.join(root, "node_modules/typescript/lib/tsserver.js")
+    await Filesystem.write(file, "export {}\n")
+    await Filesystem.writeJson(path.join(root, "node_modules/typescript/package.json"), { name: "typescript" })
+
+    expect(Module.resolve("typescript/lib/tsserver.js", root)).toBe(file)
+  })
+
+  test("resolves packages through ancestor node_modules", async () => {
+    await using tmp = await tmpdir()
+    const root = path.join(tmp.path, "proj")
+    const cwd = path.join(root, "apps/web")
+    const file = path.join(root, "node_modules/eslint/lib/api.js")
+    await Filesystem.write(file, "export {}\n")
+    await Filesystem.writeJson(path.join(root, "node_modules/eslint/package.json"), {
+      name: "eslint",
+      main: "lib/api.js",
+    })
+    await Filesystem.write(path.join(cwd, ".keep"), "")
+
+    expect(Module.resolve("eslint", cwd)).toBe(file)
+  })
+
+  test("resolves relative to the provided dir", async () => {
+    await using tmp = await tmpdir()
+    const a = path.join(tmp.path, "a")
+    const b = path.join(tmp.path, "b")
+    const left = path.join(a, "node_modules/biome/index.js")
+    const right = path.join(b, "node_modules/biome/index.js")
+    await Filesystem.write(left, "export {}\n")
+    await Filesystem.write(right, "export {}\n")
+    await Filesystem.writeJson(path.join(a, "node_modules/biome/package.json"), {
+      name: "biome",
+      main: "index.js",
+    })
+    await Filesystem.writeJson(path.join(b, "node_modules/biome/package.json"), {
+      name: "biome",
+      main: "index.js",
+    })
+
+    expect(Module.resolve("biome", a)).toBe(left)
+    expect(Module.resolve("biome", b)).toBe(right)
+    expect(Module.resolve("biome", a)).not.toBe(Module.resolve("biome", b))
+  })
+
+  test("returns undefined when resolution fails", async () => {
+    await using tmp = await tmpdir()
+    expect(Module.resolve("missing-package", tmp.path)).toBeUndefined()
+  })
+})

package/test/util/process.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { Process } from "../../src/util/process"
+import { tmpdir } from "../fixture/fixture"
+
+function node(script: string) {
+  return [process.execPath, "-e", script]
+}
+
+describe("util.process", () => {
+  test("captures stdout and stderr", async () => {
+    const out = await Process.run(node('process.stdout.write("out");process.stderr.write("err")'))
+    expect(out.code).toBe(0)
+    expect(out.stdout.toString()).toBe("out")
+    expect(out.stderr.toString()).toBe("err")
+  })
+
+  test("returns code when nothrow is enabled", async () => {
+    const out = await Process.run(node("process.exit(7)"), { nothrow: true })
+    expect(out.code).toBe(7)
+  })
+
+  test("throws RunFailedError on non-zero exit", async () => {
+    const err = await Process.run(node('process.stderr.write("bad");process.exit(3)')).catch((error) => error)
+    expect(err).toBeInstanceOf(Process.RunFailedError)
+    if (!(err instanceof Process.RunFailedError)) throw err
+    expect(err.code).toBe(3)
+    expect(err.stderr.toString()).toBe("bad")
+  })
+
+  test("aborts a running process", async () => {
+    const abort = new AbortController()
+    const started = Date.now()
+    setTimeout(() => abort.abort(), 25)
+
+    const out = await Process.run(node("setInterval(() => {}, 1000)"), {
+      abort: abort.signal,
+      nothrow: true,
+    })
+
+    expect(out.code).not.toBe(0)
+    expect(Date.now() - started).toBeLessThan(1000)
+  }, 3000)
+
+  test("kills after timeout when process ignores terminate signal", async () => {
+    if (process.platform === "win32") return
+
+    const abort = new AbortController()
+    const started = Date.now()
+    setTimeout(() => abort.abort(), 25)
+
+    const out = await Process.run(node('process.on("SIGTERM", () => {}); setInterval(() => {}, 1000)'), {
+      abort: abort.signal,
+      nothrow: true,
+      timeout: 25,
+    })
+
+    expect(out.code).not.toBe(0)
+    expect(Date.now() - started).toBeLessThan(1000)
+  }, 3000)
+
+  test("uses cwd when spawning commands", async () => {
+    await using tmp = await tmpdir()
+    const out = await Process.run(node("process.stdout.write(process.cwd())"), {
+      cwd: tmp.path,
+    })
+    expect(out.stdout.toString()).toBe(tmp.path)
+  })
+
+  test("merges environment overrides", async () => {
+    const out = await Process.run(node('process.stdout.write(process.env.EPOCHCLI_TEST ?? "")'), {
+      env: {
+        EPOCHCLI_TEST: "set",
+      },
+    })
+    expect(out.stdout.toString()).toBe("set")
+  })
+
+  test("uses shell in run on Windows", async () => {
+    if (process.platform !== "win32") return
+
+    const out = await Process.run(["set", "EPOCHCLI_TEST_SHELL"], {
+      shell: true,
+      env: {
+        EPOCHCLI_TEST_SHELL: "ok",
+      },
+    })
+
+    expect(out.code).toBe(0)
+    expect(out.stdout.toString()).toContain("EPOCHCLI_TEST_SHELL=ok")
+  })
+
+  test("runs cmd scripts with spaces on Windows without shell", async () => {
+    if (process.platform !== "win32") return
+
+    await using tmp = await tmpdir()
+    const dir = path.join(tmp.path, "with space")
+    const file = path.join(dir, "echo cmd.cmd")
+
+    await fs.mkdir(dir, { recursive: true })
+    await Bun.write(file, "@echo off\r\nif %~1==--stdio exit /b 0\r\nexit /b 7\r\n")
+
+    const proc = Process.spawn([file, "--stdio"], {
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    expect(await proc.exited).toBe(0)
+  })
+
+  test("rejects missing commands without leaking unhandled errors", async () => {
+    await using tmp = await tmpdir()
+    const cmd = path.join(tmp.path, "missing" + (process.platform === "win32" ? ".cmd" : ""))
+    const err = await Process.spawn([cmd], {
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    }).exited.catch((err) => err)
+
+    expect(err).toBeInstanceOf(Error)
+    if (!(err instanceof Error)) throw err
+    expect(err).toMatchObject({
+      code: "ENOENT",
+    })
+  })
+})

package/test/util/telemetry-integration.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect, afterAll, beforeAll } from "bun:test"
+import * as fs from "fs/promises"
+import * as path from "path"
+import { SessionAnalyzer } from "../../src/util/session-analyzer"
+import { SessionTelemetry } from "../../src/util/session-telemetry"
+
+describe("Telemetry Integration - End-to-End State Extraction", () => {
+  const tmpDir = path.join(process.cwd(), "test-telemetry-tmp")
+
+  beforeAll(async () => {
+    await fs.mkdir(tmpDir, { recursive: true })
+    // Initialize SessionTelemetry to point to our temp dir
+    process.env.XDG_DATA_HOME = tmpDir
+  })
+
+  afterAll(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true })
+  })
+
+  it("successfully extracts completed tools from structured telemetry", async () => {
+    // 1. Mock session ID and history
+    const sessionID = "test-session-123"
+    const chatHistory = [
+      {
+        info: { role: "assistant" },
+        parts: [
+          {
+            type: "tool",
+            tool: "bash",
+            state: { status: "completed", input: { command: "spec sc_init --name eventbus" } },
+          },
+        ],
+      },
+    ] as any
+
+    // 2. Emit telemetry via SessionTelemetry
+    await SessionTelemetry.init({ dev: true })
+    SessionTelemetry.emitModelEvent({
+      mainEpochId: sessionID,
+      event: "START_GENERATE",
+      providerId: "local-main",
+      phase: "Phase 1",
+      activeAgent: "plan",
+    } as any)
+
+    SessionTelemetry.emitToolEvent({
+      sessionID,
+      callID: "call_init",
+      event: "TOOL_START",
+      tool: "bash",
+      input: { command: "spec sc_init --name eventbus" },
+    } as any)
+
+    SessionTelemetry.emitToolEvent({
+      sessionID,
+      callID: "call_init",
+      event: "TOOL_END",
+      tool: "bash",
+      status: "completed",
+      output: "Successfully ran: spec sc_init --name eventbus",
+    } as any)
+
+    SessionTelemetry.emitModelEvent({
+      mainEpochId: sessionID,
+      event: "END_GENERATE",
+      metrics: { promptTokens: 100 },
+    } as any)
+
+    await SessionTelemetry.flush()
+
+    // 3. Analyze via SessionAnalyzer
+    const analysis = await SessionAnalyzer.analyze(sessionID, chatHistory, process.cwd())
+
+    // 4. Verify results
+    // Updated expectation: The timeline uses semantically mapped tool names and Turn indexing
+    expect(analysis.actionTimeline).toContain(
+      'Turn 1: Tool \'sc_init\' executed (input: {"command":"spec sc_init --name eventbus"}) -> Result: completed',
+    )
+  })
+
+  it("handles failed tools correctly", async () => {
+    const sessionID = "test-session-456"
+    const chatHistory = [] as any
+
+    await SessionTelemetry.init({ dev: true })
+    SessionTelemetry.emitModelEvent({
+      mainEpochId: sessionID,
+      event: "START_GENERATE",
+    } as any)
+
+    SessionTelemetry.emitToolEvent({
+      sessionID,
+      event: "TOOL_END",
+      tool: "read",
+      status: "failed",
+      error: "File not found",
+    })
+
+    await SessionTelemetry.flush()
+
+    const analysis = await SessionAnalyzer.analyze(sessionID, chatHistory, process.cwd())
+    expect(analysis.telemetry.mcpxFailures).toContain("read: File not found")
+  })
+})

package/test/util/timeout.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from "bun:test"
+import { withTimeout } from "../../src/util/timeout"
+
+describe("util.timeout", () => {
+  test("should resolve when promise completes before timeout", async () => {
+    const fastPromise = new Promise<string>((resolve) => {
+      setTimeout(() => resolve("fast"), 10)
+    })
+
+    const result = await withTimeout(fastPromise, 100)
+    expect(result).toBe("fast")
+  })
+
+  test("should reject when promise exceeds timeout", async () => {
+    const slowPromise = new Promise<string>((resolve) => {
+      setTimeout(() => resolve("slow"), 200)
+    })
+
+    await expect(withTimeout(slowPromise, 50)).rejects.toThrow("Operation timed out after 50ms")
+  })
+})

package/test/util/which.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { which } from "../../src/util/which"
+import { tmpdir } from "../fixture/fixture"
+
+async function cmd(dir: string, name: string, exec = true) {
+  const ext = process.platform === "win32" ? ".cmd" : ""
+  const file = path.join(dir, name + ext)
+  const body = process.platform === "win32" ? "@echo off\r\n" : "#!/bin/sh\n"
+  await fs.writeFile(file, body)
+  if (process.platform !== "win32") {
+    await fs.chmod(file, exec ? 0o755 : 0o644)
+  }
+  return file
+}
+
+function env(PATH: string): NodeJS.ProcessEnv {
+  return {
+    PATH,
+    PATHEXT: process.env["PATHEXT"],
+  }
+}
+
+function envPath(Path: string): NodeJS.ProcessEnv {
+  return {
+    Path,
+    PathExt: process.env["PathExt"] ?? process.env["PATHEXT"],
+  }
+}
+
+function same(a: string | null, b: string) {
+  if (process.platform === "win32") {
+    expect(a?.toLowerCase()).toBe(b.toLowerCase())
+    return
+  }
+
+  expect(a).toBe(b)
+}
+
+describe("util.which", () => {
+  test("returns null when command is missing", () => {
+    expect(which("epochcli-missing-command-for-test")).toBeNull()
+  })
+
+  test("finds a command from PATH override", async () => {
+    await using tmp = await tmpdir()
+    const bin = path.join(tmp.path, "bin")
+    await fs.mkdir(bin)
+    const file = await cmd(bin, "tool")
+
+    same(which("tool", env(bin)), file)
+  })
+
+  test("uses first PATH match", async () => {
+    await using tmp = await tmpdir()
+    const a = path.join(tmp.path, "a")
+    const b = path.join(tmp.path, "b")
+    await fs.mkdir(a)
+    await fs.mkdir(b)
+    const first = await cmd(a, "dupe")
+    await cmd(b, "dupe")
+
+    same(which("dupe", env([a, b].join(path.delimiter))), first)
+  })
+
+  test("returns null for non-executable file on unix", async () => {
+    if (process.platform === "win32") return
+
+    await using tmp = await tmpdir()
+    const bin = path.join(tmp.path, "bin")
+    await fs.mkdir(bin)
+    await cmd(bin, "noexec", false)
+
+    expect(which("noexec", env(bin))).toBeNull()
+  })
+
+  test("uses PATHEXT on windows", async () => {
+    if (process.platform !== "win32") return
+
+    await using tmp = await tmpdir()
+    const bin = path.join(tmp.path, "bin")
+    await fs.mkdir(bin)
+    const file = path.join(bin, "pathext.CMD")
+    await fs.writeFile(file, "@echo off\r\n")
+
+    expect(which("pathext", { PATH: bin, PATHEXT: ".CMD" })).toBe(file)
+  })
+
+  test("uses Windows Path casing fallback", async () => {
+    if (process.platform !== "win32") return
+
+    await using tmp = await tmpdir()
+    const bin = path.join(tmp.path, "bin")
+    await fs.mkdir(bin)
+    const file = await cmd(bin, "mixed")
+
+    same(which("mixed", envPath(bin)), file)
+  })
+})

package/test/util/wildcard.test.ts

@@ -0,0 +1,90 @@
+import { test, expect } from "bun:test"
+import { Wildcard } from "../../src/util/wildcard"
+
+test("match handles glob tokens", () => {
+  expect(Wildcard.match("file1.txt", "file?.txt")).toBe(true)
+  expect(Wildcard.match("file12.txt", "file?.txt")).toBe(false)
+  expect(Wildcard.match("foo+bar", "foo+bar")).toBe(true)
+})
+
+test("match with trailing space+wildcard matches command with or without args", () => {
+  // "ls *" should match "ls" (no args) and "ls -la" (with args)
+  expect(Wildcard.match("ls", "ls *")).toBe(true)
+  expect(Wildcard.match("ls -la", "ls *")).toBe(true)
+  expect(Wildcard.match("ls foo bar", "ls *")).toBe(true)
+
+  // "ls*" (no space) should NOT match "ls" alone — wait, it should because .* matches empty
+  // but it WILL match "lstmeval" which is the dangerous case users should avoid
+  expect(Wildcard.match("ls", "ls*")).toBe(true)
+  expect(Wildcard.match("lstmeval", "ls*")).toBe(true)
+
+  // "ls *" (with space) should NOT match "lstmeval"
+  expect(Wildcard.match("lstmeval", "ls *")).toBe(false)
+
+  // multi-word commands
+  expect(Wildcard.match("git status", "git *")).toBe(true)
+  expect(Wildcard.match("git", "git *")).toBe(true)
+  expect(Wildcard.match("git commit -m foo", "git *")).toBe(true)
+})
+
+test("all picks the most specific pattern", () => {
+  const rules = {
+    "*": "deny",
+    "git *": "ask",
+    "git status": "allow",
+  }
+  expect(Wildcard.all("git status", rules)).toBe("allow")
+  expect(Wildcard.all("git log", rules)).toBe("ask")
+  expect(Wildcard.all("echo hi", rules)).toBe("deny")
+})
+
+test("allStructured matches command sequences", () => {
+  const rules = {
+    "git *": "ask",
+    "git status*": "allow",
+  }
+  expect(Wildcard.allStructured({ head: "git", tail: ["status", "--short"] }, rules)).toBe("allow")
+  expect(Wildcard.allStructured({ head: "npm", tail: ["run", "build", "--watch"] }, { "npm run *": "allow" })).toBe(
+    "allow",
+  )
+  expect(Wildcard.allStructured({ head: "ls", tail: ["-la"] }, rules)).toBeUndefined()
+})
+
+test("allStructured prioritizes flag-specific patterns", () => {
+  const rules = {
+    "find *": "allow",
+    "find * -delete*": "ask",
+    "sort*": "allow",
+    "sort -o *": "ask",
+  }
+  expect(Wildcard.allStructured({ head: "find", tail: ["src", "-delete"] }, rules)).toBe("ask")
+  expect(Wildcard.allStructured({ head: "find", tail: ["src", "-print"] }, rules)).toBe("allow")
+  expect(Wildcard.allStructured({ head: "sort", tail: ["-o", "out.txt"] }, rules)).toBe("ask")
+  expect(Wildcard.allStructured({ head: "sort", tail: ["--reverse"] }, rules)).toBe("allow")
+})
+
+test("allStructured handles sed flags", () => {
+  const rules = {
+    "sed * -i*": "ask",
+    "sed -n*": "allow",
+  }
+  expect(Wildcard.allStructured({ head: "sed", tail: ["-i", "file"] }, rules)).toBe("ask")
+  expect(Wildcard.allStructured({ head: "sed", tail: ["-i.bak", "file"] }, rules)).toBe("ask")
+  expect(Wildcard.allStructured({ head: "sed", tail: ["-n", "1p", "file"] }, rules)).toBe("allow")
+  expect(Wildcard.allStructured({ head: "sed", tail: ["-i", "-n", "/./p", "myfile.txt"] }, rules)).toBe("ask")
+})
+
+test("match normalizes slashes for cross-platform globbing", () => {
+  expect(Wildcard.match("C:\\Windows\\System32\\*", "C:/Windows/System32/*")).toBe(true)
+  expect(Wildcard.match("C:/Windows/System32/drivers", "C:\\Windows\\System32\\*")).toBe(true)
+})
+
+test("match handles case-insensitivity on Windows", () => {
+  if (process.platform === "win32") {
+    expect(Wildcard.match("C:\\windows\\system32\\hosts", "C:/Windows/System32/*")).toBe(true)
+    expect(Wildcard.match("c:/windows/system32/hosts", "C:\\Windows\\System32\\*")).toBe(true)
+  } else {
+    // Unix paths are case-sensitive
+    expect(Wildcard.match("/users/test/file", "/Users/test/*")).toBe(false)
+  }
+})

package/test-regex.js

@@ -0,0 +1,50 @@
+const content = `expert_dev_guidance:
+
+  - rule:
+      id: TS-001
+      Trigger: Whenever iterating over an array structure or collection of data.
+      Behaviour: Never use for...in on arrays. Always use for...of to iterate over values safely, or utilize standard functional methods like .map() and .filter().
+      Example:
+        Correct:
+        <|">
+        for (const item of items) {
+    process(item);
+}
+        <|">
+        Incorrect:
+        <|">
+        for (const i in items) {
+    process(items[i]);
+}
+        <|">
+
+
+  - rule:
+      id: TS-002
+      Trigger: Writing functions that handle external I/O, file system parsing, or non-deterministic API calls.
+      Behaviour: Do not use throw new Error(). Implement a Discriminated Union Result type returning { success: true, data: T } or { success: false, error: Error } to enforce compiler error checking.
+      Example:
+        Correct:
+        <|">
+        type Result<T> = { ok: true, val: T } | { ok: false, err: Error };
+return parseSafe(data);
+        <|">
+        Incorrect:
+        <|">
+        try {
+    return parse(data);
+} catch (e) {
+    throw new Error(e);
+}
+        <|">`
+
+const devRulesRegex =
+  /- rule:\s*id:\s*([^\n]+)\s*Trigger:\s*([^\n]+)\s*Behaviour:\s*([^\n]+)\s*Example:([\s\S]*?)(?=- rule:|$)/g
+let match
+while ((match = devRulesRegex.exec(content)) !== null) {
+  console.log("ID:", match[1].trim())
+  console.log("Trigger:", match[2].trim())
+  console.log("Behaviour:", match[3].trim())
+  console.log("Example:", match[4].trim())
+  console.log("---")
+}