@far-world-labs/verblets 0.3.2 → 0.5.0

package/dist/index.js

@@ -1,149 +1,147 @@
-import { r as P, a as C, b as x, c as v, d as R } from "./shared-C6kPWghF.js";
-import { E as me, a3 as fe, f as ye, F as ge, l as Se, G as be, H as Ce, e as Ie, I as we, k as $e, g as Ee, m as Pe, o as xe, J as ve, K as Re, L as Fe, p as Ae, i as Te, a4 as _e, a5 as De, q as Oe, M as ke, t as Le, N as Ne, u as je, v as Me, w as Ue, a6 as Be, x as ze, O as Je, y as Ge, z as Ve, a7 as qe, a8 as He, A as Xe, P as We, Q as Ke, n as Ye, h as Ze, R as Qe, a8 as es, S as ss, ab as ts, ae as as, T as ns, U as rs, ac as is, ad as os, j as cs, V as ls, af as us, B as ds, a9 as ps, s as hs, aa as ms, W as fs, C as ys, X as gs, Y as Ss, Z as bs, D as Cs, _ as Is, $ as ws, a0 as $s, a1 as Es, a2 as Ps } from "./shared-C6kPWghF.js";
-import p from "node:fs";
-import "node:path";
+import P from "dotenv";
+import p, { readFileSync as F } from "node:fs";
+import { resolve as x } from "node:path";
+import { r as A, a as E, n as $, c as O, b as D, d as N, j as L } from "./shared-C2_d1bKV.js";
+import { cz as Ee, F as Te, C as Re, G as we, aQ as ve, D as Pe, E as Fe, ao as xe, Q as Ae, bg as $e, bj as Oe, c1 as De, bx as Ne, c0 as Le, $ as Me, A as ke, a8 as _e, _ as Be, b6 as je, o as Ue, au as ze, aE as Ge, bv as Je, f as Ve, aN as qe, a5 as We, y as He, z as Xe, aM as Ke, bt as Ye, a1 as Qe, a2 as Ze, ch as es, bW as ss, i as as, aO as ts, bU as rs, aP as ns, ci as is, bl as os, cB as cs, e as ls, aR as us, cj as ds, bY as ps, B as ms, H as hs, a9 as fs, b7 as bs, p as gs, aF as ys, aG as Ss, R as Is, g as Cs, bX as Es, O as Ts, a3 as Rs, a4 as ws, ap as vs, aS as Ps, aU as Fs, aW as xs, aX as As, bD as $s, bS as Os, bE as Ds, bQ as Ns, bF as Ls, bR as Ms, bK as ks, bP as _s, bO as Bs, bJ as js, bN as Us, bI as zs, bT as Gs, bL as Js, bM as Vs, bG as qs, a6 as Ws, ab as Hs, ad as Xs, ae as Ks, aa as Ys, ac as Qs, a7 as Zs, Y as ea, Z as sa, S as aa, bw as ta, af as ra, c8 as na, aY as ia, ag as oa, aZ as ca, ah as la, am as ua, cy as da, aT as pa, K as ma, L as ha, M as fa, ai as ba, aj as ga, cA as ya, by as Sa, ak as Ia, a_ as Ca, ck as Ea, al as Ta, an as Ra, aq as wa, bz as va, bA as Pa, ar as Fa, a$ as xa, b0 as Aa, bZ as $a, h as Oa, k as Da, I as Na, J as La, cl as Ma, b_ as ka, b$ as _a, cg as Ba, b8 as ja, b9 as Ua, b1 as za, bA as Ga, cm as Ja, cs as Va, b2 as qa, x as Wa, cv as Ha, cw as Xa, ct as Ka, b3 as Ya, bV as Qa, b5 as Za, b4 as et, bb as st, bd as at, be as tt, ba as rt, bc as nt, cx as it, c3 as ot, l as ct, t as lt, v as ut, w as dt, q as pt, u as mt, m as ht, bf as ft, cu as bt, bs as gt, c4 as yt, as as St, ax as It, az as Ct, aA as Et, av as Tt, aw as Rt, ay as wt, at as vt, bB as Pt, s as Ft, bH as xt, bC as At, cr as $t, aV as Ot, bh as Dt, bu as Nt, aB as Lt, cn as Mt, bi as kt, ca as _t, c9 as Bt, a0 as jt, aD as Ut, bk as zt, aC as Gt, aI as Jt, aK as Vt, aL as qt, aH as Wt, aJ as Ht, U as Xt, V as Kt, T as Yt, X as Qt, c2 as Zt, bm as er, bn as sr, cb as ar, cd as tr, ce as rr, cc as nr, cf as ir, bo as or, bp as cr, co as lr, W as ur, P as dr, cp as pr, br as mr, bq as hr, c5 as fr, c6 as br, c7 as gr, N as yr, cq as Sr } from "./shared-C2_d1bKV.js";
 import "glob";
-import F from "node:fs/promises";
-const I = 1, A = 20, T = 5, _ = 0.5, D = 5, S = 8e3, g = 5, f = {
+import M from "node:fs/promises";
+const k = (e) => {
+}, T = 1, _ = 20, B = 5, j = 0.5, U = 5, y = 8e3, g = 5, f = {
   INDIVIDUAL: "individual",
   BULK: "bulk"
-}, h = {
+}, m = {
   PROCESSING: "processing",
   COMPLETED: "completed",
   ERROR: "error"
 };
-function O(e, s) {
-  const a = [];
-  for (let t = 0; t < e.length; t += s)
-    a.push({
-      items: e.slice(t, t + s),
-      index: Math.floor(t / s) + 1,
-      startIndex: t
+function z(e, s) {
+  const t = [];
+  for (let a = 0; a < e.length; a += s)
+    t.push({
+      items: e.slice(a, a + s),
+      index: Math.floor(a / s) + 1,
+      startIndex: a
     });
-  return a;
+  return t;
 }
-function b(e, s, a, t, n, r) {
+function S(e, s, t, a, r, i) {
   return {
     chunkIndex: e.index,
     totalChunks: s,
     itemsInChunk: e.items.length,
-    totalItems: a,
-    status: t,
-    bulkSize: n.bulkSize,
-    maxConcurrency: n.maxConcurrency,
-    processingMode: r,
+    totalItems: t,
+    status: a,
+    bulkSize: r.bulkSize,
+    maxConcurrency: r.maxConcurrency,
+    processingMode: i,
     parallelMode: !0
   };
 }
-async function k(e, s, a, t, n) {
+async function G(e, s, t, a, r) {
   try {
-    const r = a.map((l) => E(l(e))).filter(Boolean).join(`
+    const i = t.map((l) => v(l(e))).filter(Boolean).join(`
 
-`), o = [s, r].filter(Boolean).join(`
+`), o = [s, i].filter(Boolean).join(`
 
-`), i = q(o, e, t, n === "files"), c = await C(i, {
-      modelOptions: {
-        response_format: {
-          type: "json_schema",
-          json_schema: {
-            name: "arch_result",
-            schema: J
-          }
+`), n = ee(o, e, a, r === "files"), c = await E(n, {
+      response_format: {
+        type: "json_schema",
+        json_schema: {
+          name: "arch_result",
+          schema: Y
         }
       }
     });
     return { item: e, ...c, error: void 0 };
-  } catch (r) {
-    return { item: e, passed: !1, reason: `Analysis failed: ${r.message}`, error: r };
+  } catch (i) {
+    return { item: e, passed: !1, reason: `Analysis failed: ${i.message}`, error: i };
   }
 }
-function L(e, s, a, t) {
-  const n = [], r = [];
-  let o = t;
-  for (const i of e)
-    if (n.push(i), i.passed || (o++, r.push(i.error || new Error(i.reason))), !s && o >= a)
+function J(e, s, t, a) {
+  const r = [], i = [];
+  let o = a;
+  for (const n of e)
+    if (r.push(n), n.passed || (o++, i.push(n.error || new Error(n.reason))), !s && o >= t)
       break;
   return {
-    results: n,
-    errors: r,
+    results: r,
+    errors: i,
     failures: o,
-    shouldStop: !s && o >= a
+    shouldStop: !s && o >= t
   };
 }
-function m(e, s, a, t) {
-  e && e(s, a, t);
+function h(e, s, t, a) {
+  e && e(s, t, a);
 }
-async function w(e, s, a, t, n) {
-  m(t, e, void 0, {
-    ...n,
-    status: h.PROCESSING
+async function R(e, s, t, a, r) {
+  h(a, e, void 0, {
+    ...r,
+    status: m.PROCESSING
   });
   try {
-    const r = H(s, e, a), o = await P(e, r, {
-      llm: {
-        response_format: {
-          type: "json_schema",
-          json_schema: {
-            name: "arch_bulk_result",
-            schema: G
-          }
+    const i = se(s, e, t), o = await A(e, i, {
+      responseFormat: {
+        type: "json_schema",
+        json_schema: {
+          name: "arch_bulk_result",
+          schema: Q
         }
       }
-    }), i = o.results || o;
+    }), n = o.results || o;
     let c = [];
-    Array.isArray(i) ? c = i : c = e.map((y) => ({
-      path: y,
+    Array.isArray(n) ? c = n : c = e.map((b) => ({
+      path: b,
       passed: !1,
       reason: "Invalid response format"
     }));
-    const l = c.filter((y) => !y.passed).length, u = c.length - l;
-    return m(
-      t,
+    const l = c.filter((b) => !b.passed).length, u = c.length - l;
+    return h(
+      a,
       e,
       l > 0 ? new Error(`${l} items failed`) : void 0,
       {
-        ...n,
-        status: h.COMPLETED,
+        ...r,
+        status: m.COMPLETED,
         passed: u,
         failed: l
       }
     ), c;
-  } catch (r) {
-    const o = e.map((i) => ({
-      path: i,
+  } catch (i) {
+    const o = e.map((n) => ({
+      path: n,
       passed: !1,
-      reason: `Processing error: ${r.message}`
+      reason: `Processing error: ${i.message}`
     }));
-    return m(t, e, r, {
-      ...n,
-      status: h.ERROR
+    return h(a, e, i, {
+      ...r,
+      status: m.ERROR
     }), o;
   }
 }
-function N(e, s) {
-  const a = s.filter((i) => i.passed).length, t = s.length - a, n = t === 0, r = s.length < e.length, o = s.filter((i) => !i.passed);
+function V(e, s) {
+  const t = s.filter((n) => n.passed).length, a = s.length - t, r = a === 0, i = s.length < e.length, o = s.filter((n) => !n.passed);
   return {
-    passed: a,
-    failed: t,
-    allPassed: n,
-    stoppedEarly: r,
+    passed: t,
+    failed: a,
+    allPassed: r,
+    stoppedEarly: i,
     failures: o,
     total: e.length,
     processed: s.length
   };
 }
-function j(e, s, a) {
+function q(e, s, t) {
   if (e.allPassed)
     return `All ${e.processed}/${e.total} items satisfy: ${s}`;
-  const t = e.failures.slice(0, g).map((r) => `  • ${r.item}: ${r.reason || "Failed"}`).join(`
-`), n = e.failures.length > g ? `
+  const a = e.failures.slice(0, g).map((i) => `  • ${i.item}: ${i.reason || "Failed"}`).join(`
+`), r = e.failures.length > g ? `
   ... and ${e.failures.length - g} more failures` : "";
-  return `${e.failed}/${e.processed} items failed: ${s}${e.stoppedEarly && a !== I ? ` (stopped after ${a} failures)` : ""}
+  return `${e.failed}/${e.processed} items failed: ${s}${e.stoppedEarly && t !== T ? ` (stopped after ${t} failures)` : ""}
 
 Failures:
-${t}${n}`;
+${a}${r}`;
 }
-function M(e, s) {
+function W(e, s) {
   return {
     passed: e.allPassed,
     message: s,
@@ -156,127 +154,127 @@ function M(e, s) {
     }
   };
 }
-function U(e, s, a, t) {
-  const n = s || a.length > 0 || t <= D;
+function H(e, s, t, a) {
+  const r = s || t.length > 0 || a <= U;
   return {
-    mode: n ? f.INDIVIDUAL : f.BULK,
-    batchSize: n ? e.maxConcurrency : e.bulkSize,
-    processor: n ? (r, o, i) => $(r, o, i) : (r, o, i) => w(
-      r.items,
+    mode: r ? f.INDIVIDUAL : f.BULK,
+    batchSize: r ? e.maxConcurrency : e.bulkSize,
+    processor: r ? (i, o, n) => w(i, o, n) : (i, o, n) => R(
+      i.items,
       o,
-      i.description,
-      i.onProgress,
-      i.metadata
+      n.description,
+      n.onProgress,
+      n.metadata
     )
   };
 }
-async function $(e, s, a) {
-  const t = e.items.map(
-    (n) => k(
-      n,
+async function w(e, s, t) {
+  const a = e.items.map(
+    (r) => G(
+      r,
       s,
-      a.itemContextFns,
-      a.description,
-      a.targetType
+      t.itemContextFns,
+      t.description,
+      t.targetType
     )
   );
-  return await Promise.all(t);
+  return await Promise.all(a);
 }
-function B(e, s, a) {
+function X(e, s, t) {
   if (s === f.INDIVIDUAL) {
-    const { results: t, errors: n, failures: r, shouldStop: o } = L(
+    const { results: a, errors: r, failures: i, shouldStop: o } = J(
       e,
-      a.isCoverageTest,
-      a.maxFailures,
-      a.currentFailures || 0
+      t.isCoverageTest,
+      t.maxFailures,
+      t.currentFailures || 0
     );
     return {
-      results: t,
-      errors: n,
-      failures: r,
+      results: a,
+      errors: r,
+      failures: i,
       shouldStop: o,
       progressData: {
-        passed: t.filter((i) => i.passed).length,
-        failed: n.length
+        passed: a.filter((n) => n.passed).length,
+        failed: r.length
       }
     };
   } else {
-    const t = e.map((n) => ({
-      item: n.path,
-      passed: n.passed,
-      reason: n.reason
+    const a = e.map((r) => ({
+      item: r.path,
+      passed: r.passed,
+      reason: r.reason
     }));
     return {
-      results: t,
+      results: a,
       errors: [],
-      failures: a.currentFailures || 0,
+      failures: t.currentFailures || 0,
       shouldStop: !1,
       progressData: {
-        passed: t.filter((n) => n.passed).length,
-        failed: t.filter((n) => !n.passed).length
+        passed: a.filter((r) => r.passed).length,
+        failed: a.filter((r) => !r.passed).length
       }
     };
   }
 }
-async function z(e, s, a, t) {
-  const n = O(e, a.batchSize), r = [];
+async function K(e, s, t, a) {
+  const r = z(e, t.batchSize), i = [];
   let o = 0;
-  for (const i of n) {
-    if (!t.isCoverageTest && o >= t.maxFailures)
+  for (const n of r) {
+    if (!a.isCoverageTest && o >= a.maxFailures)
       break;
-    const c = b(
-      i,
-      n.length,
+    const c = S(
+      n,
+      r.length,
       e.length,
-      h.PROCESSING,
-      t,
-      a.mode
+      m.PROCESSING,
+      a,
+      t.mode
     );
-    m(t.onChunkProcessed, i.items, void 0, c);
+    h(a.onChunkProcessed, n.items, void 0, c);
     let l;
-    a.mode === f.INDIVIDUAL ? l = await $(i, s, {
-      itemContextFns: t.itemContextFns,
-      description: t.description,
-      targetType: t.targetType
-    }) : l = await w(
-      i.items,
+    t.mode === f.INDIVIDUAL ? l = await w(n, s, {
+      itemContextFns: a.itemContextFns,
+      description: a.description,
+      targetType: a.targetType
+    }) : l = await R(
+      n.items,
       s,
-      t.description,
-      t.onChunkProcessed,
+      a.description,
+      a.onChunkProcessed,
       c
     );
-    const u = B(l, a.mode, {
-      ...t,
+    const u = X(l, t.mode, {
+      ...a,
       currentFailures: o
     });
-    if (r.push(...u.results), o = u.failures, m(
-      t.onChunkProcessed,
-      i.items,
+    if (i.push(...u.results), o = u.failures, h(
+      a.onChunkProcessed,
+      n.items,
       u.errors.length > 0 ? u.errors[0] : void 0,
       {
-        ...b(
-          i,
-          n.length,
+        ...S(
+          n,
+          r.length,
           e.length,
-          h.COMPLETED,
-          t,
-          a.mode
+          m.COMPLETED,
+          a,
+          t.mode
         ),
         ...u.progressData
       }
     ), u.shouldStop)
       break;
   }
-  return r;
+  return i;
 }
-const J = {
+const Y = {
   type: "object",
   properties: {
     passed: { type: "boolean" },
     reason: { type: "string" }
   },
   required: ["passed", "reason"]
-}, G = {
+}, Q = {
   type: "object",
   properties: {
     results: {
@@ -294,7 +292,7 @@ const J = {
   },
   required: ["results"]
 };
-function E(e) {
+function v(e) {
   switch (e.type) {
     case "file":
       return p.existsSync(e.filePath) ? `<${e.name}>
@@ -317,38 +315,38 @@ ${s}
       return "";
   }
 }
-function V(e) {
+function Z(e) {
   if (!p.existsSync(e)) return "Item does not exist";
   if (p.statSync(e).isDirectory())
     return p.readdirSync(e).join(", ");
   {
-    const a = p.readFileSync(e, "utf8");
-    return a.length > S ? `${a.substring(0, S)}
-... (truncated)` : a;
+    const t = p.readFileSync(e, "utf8");
+    return t.length > y ? `${t.substring(0, y)}
+... (truncated)` : t;
   }
 }
-function q(e, s, a, t) {
-  const n = V(s);
+function ee(e, s, t, a) {
+  const r = Z(s);
   return `${e}
-Analyze this ${t ? "file" : "directory"}: ${s}
+Analyze this ${a ? "file" : "directory"}: ${s}
 
 Content:
-${n}
+${r}
 
-Does it satisfy: "${a}"?
+Does it satisfy: "${t}"?
 
 Return JSON with "passed" (boolean) and "reason" (string).`;
 }
-function H(e, s, a) {
+function se(e, s, t) {
   return `${e}
-Analyze each item and determine if it satisfies: "${a}"
+Analyze each item and determine if it satisfies: "${t}"
 Items: ${s.join(", ")}
 
 Return JSON with "results" array containing objects with "path", "passed" (boolean), and "reason" (string).`;
 }
-class X {
-  constructor(s, a = {}) {
-    this.target = s, this.contexts = [], this.itemContextFns = [], this.maxFailures = a.maxFailures || I, this.bulkSize = a.bulkSize || A, this.maxConcurrency = a.maxConcurrency || T, this.onChunkProcessed = void 0, this.description = void 0, this.threshold = void 0, this.isCoverageTest = !1;
+class ae {
+  constructor(s, t = {}) {
+    this.target = s, this.contexts = [], this.itemContextFns = [], this.maxFailures = t.maxFailures || T, this.bulkSize = t.bulkSize || _, this.maxConcurrency = t.maxConcurrency || B, this.onChunkProcessed = void 0, this.description = void 0, this.threshold = void 0, this.isCoverageTest = !1;
   }
   withContext(s) {
     return this.contexts.push(s), this;
@@ -361,21 +359,21 @@ class X {
     return this.description = s, this;
   }
   // Set up for a coverage test
-  coverage(s = _) {
+  coverage(s = j) {
     return this.threshold = s, this.isCoverageTest = !0, this;
   }
   // Start processing - this is the fluent terminator
   async start() {
     if (!this.description)
       throw new Error("Must call satisfies() before start()");
-    const s = await this.target.resolve(), a = this.contexts.map(E).filter(Boolean).join(`
+    const s = await this.target.resolve(), t = this.contexts.map(v).filter(Boolean).join(`
 
-`), t = U(
+`), a = H(
       this,
       this.onChunkProcessed,
       this.itemContextFns,
       s.length
-    ), n = {
+    ), r = {
       bulkSize: this.bulkSize,
       maxConcurrency: this.maxConcurrency,
       description: this.description,
@@ -384,29 +382,29 @@ class X {
       targetType: this.target.type,
       maxFailures: this.maxFailures,
       isCoverageTest: this.isCoverageTest
-    }, r = await z(s, a, t, n);
+    }, i = await K(s, t, a, r);
     if (this.isCoverageTest) {
-      const o = r.filter((u) => u.passed).length, i = s.length > 0 ? o / s.length : 0, c = i >= this.threshold, l = `Coverage: ${o}/${s.length} (${(i * 100).toFixed(1)}%) - ${c ? "meets" : "below"} ${(this.threshold * 100).toFixed(1)}% threshold`;
+      const o = i.filter((u) => u.passed).length, n = s.length > 0 ? o / s.length : 0, c = n >= this.threshold, l = `Coverage: ${o}/${s.length} (${(n * 100).toFixed(1)}%) - ${c ? "meets" : "below"} ${(this.threshold * 100).toFixed(1)}% threshold`;
       if (!c)
         throw new Error(l);
-      return { passed: c, coverage: i, message: l };
+      return { passed: c, coverage: n, message: l };
     }
-    return this.summarize(s, r);
+    return this.summarize(s, i);
   }
-  summarize(s, a) {
-    const t = N(s, a), n = j(t, this.description, this.maxFailures);
-    if (!t.allPassed)
-      throw new Error(n);
-    return M(t, n);
+  summarize(s, t) {
+    const a = V(s, t), r = q(a, this.description, this.maxFailures);
+    if (!a.allPassed)
+      throw new Error(r);
+    return W(a, r);
   }
 }
-function le(e, s = {}) {
-  return new X(e, s);
+function ge(e, s = {}) {
+  return new ae(e, s);
 }
-function ue() {
+function ye() {
   return console.warn("scanJS is not available in browser environment"), Promise.resolve({});
 }
-const W = {
+const I = {
   name: "test_analysis_result",
   schema: {
     type: "object",
@@ -427,12 +425,14 @@ const W = {
     required: ["hasIssues", "issues"],
     additionalProperties: !1
   }
-};
-async function d(e, s, a = {}) {
+}, C = "test";
+async function d(e, s, t = {}) {
+  const a = $(C, t), r = O(C, a.onProgress, a);
+  r.start();
   try {
-    const t = await F.readFile(e, "utf-8"), n = `Analyze this code and ${s}:
+    const i = await M.readFile(e, "utf-8"), o = `Analyze this code and ${s}:
 
-${x(t, { tag: "code-to-analyze" })}
+${D(i, { tag: "code-to-analyze" })}
 
 Return a JSON object with:
 - "hasIssues": boolean indicating if any issues were found
@@ -443,106 +443,259 @@ GUIDELINES:
 - Provide specific line numbers or code references when possible
 - Suggest concrete fixes for each issue identified
 - Be concise but clear in your feedback
-- If no issues are found, return {"hasIssues": false, "issues": []}
-
-${v}`, r = await C(n, {
-      ...a,
-      modelOptions: {
-        ...a.modelOptions,
-        response_format: {
-          type: "json_schema",
-          json_schema: W
-        }
+- If no issues are found, return {"hasIssues": false, "issues": []}`, n = await N(
+      () => E(o, {
+        ...a,
+        response_format: L(I.name, I.schema)
+      }),
+      {
+        label: "test chain",
+        config: a
       }
-    });
-    return r.hasIssues ? r.issues : [];
-  } catch (t) {
-    return [`Error analyzing ${e}: ${t.message}`];
+    ), c = n.hasIssues ? n.issues : [];
+    return r.complete(), c;
+  } catch (i) {
+    return [`Error analyzing ${e}: ${i.message}`];
   }
 }
-const K = "Run the code with 5 boundary value test cases and report any that fail", Y = "Identify 5 passing scenarios and significant boundary conditions in this code. Provide minimal input examples for each scenario to demonstrate correctness.", Z = "Identify 5 failing scenarios and significant boundary conditions in this code. Provide minimal input examples for each scenario to demonstrate the failure. Assume DBC, and don't complain when types are specified in jsDoc.", Q = "Identify 5 defects in this code. Provide minimal input examples to demonstrate each defect.", ee = "Suggest 5 best practices improvements for this code.", se = 'Suggest 5 "clean code" improvements for this code.', te = "Identify 5 specific issues related to code quality, readability, and maintainability.", ae = "Suggest 5 refactors that would most improve the composibility of this code.", de = async (e) => [
-  ...await d(e, K),
-  ...await d(e, Y),
-  ...await d(e, Z),
-  ...await d(e, Q),
-  ...await d(e, ee),
-  ...await d(e, se),
+const te = "Run the code with 5 boundary value test cases and report any that fail", re = "Identify 5 passing scenarios and significant boundary conditions in this code. Provide minimal input examples for each scenario to demonstrate correctness.", ne = "Identify 5 failing scenarios and significant boundary conditions in this code. Provide minimal input examples for each scenario to demonstrate the failure. Assume DBC, and don't complain when types are specified in jsDoc.", ie = "Identify 5 defects in this code. Provide minimal input examples to demonstrate each defect.", oe = "Suggest 5 best practices improvements for this code.", ce = 'Suggest 5 "clean code" improvements for this code.', le = "Identify 5 specific issues related to code quality, readability, and maintainability.", ue = "Suggest 5 refactors that would most improve the composibility of this code.", Se = async (e) => [
   ...await d(e, te),
-  ...await d(e, ae)
+  ...await d(e, re),
+  ...await d(e, ne),
+  ...await d(e, ie),
+  ...await d(e, oe),
+  ...await d(e, ce),
+  ...await d(e, le),
+  ...await d(e, ue)
 ];
-R.isNode && (await import("dotenv")).config();
+P.config();
+try {
+  k(JSON.parse(F(x(process.cwd(), ".verblets.json"), "utf8")));
+} catch {
+}
 export {
-  le as aiArchExpect,
-  me as anonymize,
-  fe as auto,
-  ye as bool,
-  ge as categorySamples,
-  Se as centralTendency,
-  C as chatGPT,
-  be as collectTerms,
-  Ce as commonalities,
-  Ie as constants,
-  we as conversation,
-  $e as createScale,
-  Ee as date,
-  C as default,
-  Pe as detectPatterns,
-  xe as detectThreshold,
-  ve as disambiguate,
-  Re as dismantle,
-  Fe as documentShrink,
-  Ae as entities,
-  Te as enums,
-  _e as expect,
-  De as expectChain,
-  Oe as extractBlocks,
-  ke as fillMissing,
-  Le as filter,
-  Ne as filterAmbiguous,
-  je as find,
-  Me as glossary,
-  Ue as group,
-  Be as intent,
-  ze as intersections,
-  Je as join,
-  Ge as list,
-  Ve as listExpand,
-  qe as llmLogger,
-  He as makePrompt,
-  Xe as map,
-  We as name,
-  Ke as nameSimilarTo,
-  Ye as number,
-  Ze as numberWithUnits,
-  Qe as people,
-  es as phailForge,
-  ss as popReference,
-  ts as promptCache,
-  as as prompts,
-  ns as questions,
-  P as reduce,
-  rs as relations,
-  is as retry,
-  os as ringBuffer,
-  cs as scale,
-  ue as scanJS,
-  ls as schemaOrg,
-  us as schemas,
-  ds as score,
-  ps as sentiment,
-  hs as services,
-  ms as setInterval,
-  fs as socratic,
-  ys as sort,
-  gs as split,
-  Ss as summaryMap,
-  bs as tagVocabulary,
-  Cs as tags,
+  Ee as CAPABILITY_KEYS,
+  Te as COMPLIANCE,
+  Re as CONTEXT_KINDS,
+  we as COST_POSTURE,
+  ve as Conversation,
+  Pe as DOMAIN,
+  Fe as ENVIRONMENT,
+  xe as ListStyle,
+  Ae as QUALITY_INTENT,
+  $e as SocraticMethod,
+  Oe as SummaryMap,
+  De as TimedAbortController,
+  ge as aiArchExpect,
+  Ne as aiExpect,
+  Le as anySignal,
+  Me as applyAllTargetingRules,
+  ke as applyCalibrate,
+  _e as applyEntities,
+  Be as applyFirstTargetingRule,
+  je as applyRelations,
+  Ue as applyScale,
+  ze as applyScore,
+  Ge as applyTags,
+  Je as auto,
+  Ve as bool,
+  qe as buildSeedGenerationPrompt,
+  We as calculateStatistics,
+  He as calibrate,
+  Xe as calibrateSpec,
+  Ke as categorySamples,
+  Ye as causalFramePrompt,
+  Qe as centralTendency,
+  Ze as centralTendencyLines,
+  es as chunk,
+  ss as chunkSentences,
+  as as classify,
+  ts as collectTerms,
+  rs as combinations,
+  ns as commonalities,
+  is as compact,
+  os as computeTagStatistics,
+  cs as config,
+  ls as constants,
+  us as conversationTurnReduce,
+  ds as cosineSimilarity,
+  ps as createBatches,
+  ms as createCalibratedClassifier,
+  hs as createContextBuilder,
+  fs as createEntityExtractor,
+  O as createProgressEmitter,
+  bs as createRelationExtractor,
+  gs as createScale,
+  ys as createTagExtractor,
+  Ss as createTagger,
+  Is as createTraceCollector,
+  Cs as date,
+  Es as debug,
+  E as default,
+  Ts as descriptorToSchema,
+  Rs as detectPatterns,
+  ws as detectThreshold,
+  vs as determineStyle,
+  Ps as disambiguate,
+  Fs as dismantle,
+  xs as dismantleFactory,
+  As as documentShrink,
+  $s as embed,
+  Os as embedAssembleSpan,
+  Ds as embedBatch,
+  Ns as embedBuildIndex,
+  Ls as embedChunked,
+  Ms as embedMergeRanges,
+  ks as embedMultiQuery,
+  _s as embedNeighborChunks,
+  Bs as embedNormalizeText,
+  js as embedRewriteQuery,
+  Us as embedRewriteToOutputDoc,
+  zs as embedScore,
+  Gs as embedStandaloneSpan,
+  Js as embedStepBack,
+  Vs as embedSubquestions,
+  qs as embedWarmup,
+  Ws as entities,
+  Hs as entitiesFilterInstructions,
+  Xs as entitiesFindInstructions,
+  Ks as entitiesGroupInstructions,
+  Ys as entitiesMapInstructions,
+  Qs as entitiesReduceInstructions,
+  Zs as entitySpec,
+  ea as evaluateTargetingClause,
+  sa as evaluateTargetingRule,
+  aa as eventToTrace,
+  ta as expect,
+  ra as extractBlocks,
+  na as extractJson,
+  ia as fillMissing,
+  oa as filter,
+  ca as filterAmbiguous,
+  la as find,
+  ua as generateList,
+  da as getCapabilities,
+  pa as getMeanings,
+  ma as getOption,
+  ha as getOptionDetail,
+  fa as getOptions,
+  ba as glossary,
+  ga as group,
+  ya as init,
+  Sa as intent,
+  Ia as intersections,
+  Ca as join,
+  Ea as last,
+  Ta as list,
+  Ra as listBatch,
+  wa as listExpand,
+  E as llm,
+  va as llmLogger,
+  Pa as makePrompt,
+  Fa as map,
+  xa as name,
+  Aa as nameSimilarTo,
+  $ as nameStep,
+  $a as normalizeLlm,
+  Oa as number,
+  Da as numberWithUnits,
+  Na as observeApplication,
+  La as observeProviders,
+  Ma as omit,
+  ka as parallel,
+  _a as parallelMap,
+  Ba as parseLLMList,
+  ja as parseRDFLiteral,
+  Ua as parseRelations,
+  za as people,
+  Ga as phailForge,
+  Ja as pick,
+  Va as pipe,
+  qa as popReference,
+  Wa as probeScan,
+  Ha as promptCache,
+  Xa as promptPiece,
+  Ka as prompts,
+  Ya as questions,
+  Qa as rangeCombinations,
+  A as reduce,
+  Za as relationSpec,
+  et as relations,
+  st as relationsFilterInstructions,
+  at as relationsFindInstructions,
+  tt as relationsGroupInstructions,
+  rt as relationsMapInstructions,
+  nt as relationsReduceInstructions,
+  it as resolveModel,
+  N as retry,
+  ot as ringBuffer,
+  ct as scale,
+  lt as scaleFilterInstructions,
+  ut as scaleFindInstructions,
+  dt as scaleGroupInstructions,
+  pt as scaleMapInstructions,
+  mt as scaleReduceInstructions,
+  ht as scaleSpec,
+  ye as scanJS,
+  ft as schemaOrg,
+  bt as schemas,
+  gt as scientificFramingPrompt,
+  yt as scopePhase,
+  St as score,
+  It as scoreFilterInstructions,
+  Ct as scoreFindInstructions,
+  Et as scoreGroupInstructions,
+  Tt as scoreItem,
+  Rt as scoreMapInstructions,
+  wt as scoreReduceInstructions,
+  vt as scoreSpec,
+  Pt as sentiment,
+  Ft as services,
+  xt as setEmbedEnabled,
+  At as setInterval,
+  $t as shuffle,
+  Ot as simplifyTree,
+  Dt as socratic,
+  Nt as softCoverPrompt,
+  Lt as sort,
+  Mt as sortBy,
+  kt as split,
+  _t as stripNumeric,
+  Bt as stripResponse,
+  jt as suggestTargetingRules,
+  Ut as tagSpec,
+  zt as tagVocabulary,
+  Gt as tags,
+  Jt as tagsFilterInstructions,
+  Vt as tagsFindInstructions,
+  qt as tagsGroupInstructions,
+  Wt as tagsMapInstructions,
+  Ht as tagsReduceInstructions,
+  Xt as targetingClause,
+  Kt as targetingRule,
+  Yt as targetingRuleOps,
+  Qt as targetingRuleSchema,
+  Zt as templateReplace,
   d as test,
-  de as testAdvice,
-  Is as themes,
-  ws as timeline,
-  $s as toObject,
-  Es as truncate,
-  Ps as veiledVariants
+  Se as testAdvice,
+  er as themes,
+  sr as timeline,
+  ar as toBool,
+  tr as toDate,
+  rr as toEnum,
+  nr as toNumber,
+  ir as toNumberWithUnits,
+  or as toObject,
+  cr as truncate,
+  lr as unionBy,
+  ur as validateTargetingRules,
+  dr as valueArbitrate,
+  pr as vectorSearch,
+  mr as veiledVariantStrategies,
+  hr as veiledVariants,
+  fr as version,
+  br as windowFor,
+  gr as withInactivityTimeout,
+  yr as withPolicy,
+  Sr as zipWith
 };