@far-world-labs/verblets 0.2.0 → 0.3.2

package/dist/index.js

@@ -0,0 +1,548 @@
+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 "glob";
+import F from "node:fs/promises";
+const I = 1, A = 20, T = 5, _ = 0.5, D = 5, S = 8e3, g = 5, f = {
+  INDIVIDUAL: "individual",
+  BULK: "bulk"
+}, h = {
+  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
+    });
+  return a;
+}
+function b(e, s, a, t, n, r) {
+  return {
+    chunkIndex: e.index,
+    totalChunks: s,
+    itemsInChunk: e.items.length,
+    totalItems: a,
+    status: t,
+    bulkSize: n.bulkSize,
+    maxConcurrency: n.maxConcurrency,
+    processingMode: r,
+    parallelMode: !0
+  };
+}
+async function k(e, s, a, t, n) {
+  try {
+    const r = a.map((l) => E(l(e))).filter(Boolean).join(`
+
+`), o = [s, r].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
+          }
+        }
+      }
+    });
+    return { item: e, ...c, error: void 0 };
+  } catch (r) {
+    return { item: e, passed: !1, reason: `Analysis failed: ${r.message}`, error: r };
+  }
+}
+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)
+      break;
+  return {
+    results: n,
+    errors: r,
+    failures: o,
+    shouldStop: !s && o >= a
+  };
+}
+function m(e, s, a, t) {
+  e && e(s, a, t);
+}
+async function w(e, s, a, t, n) {
+  m(t, e, void 0, {
+    ...n,
+    status: h.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
+          }
+        }
+      }
+    }), i = o.results || o;
+    let c = [];
+    Array.isArray(i) ? c = i : c = e.map((y) => ({
+      path: y,
+      passed: !1,
+      reason: "Invalid response format"
+    }));
+    const l = c.filter((y) => !y.passed).length, u = c.length - l;
+    return m(
+      t,
+      e,
+      l > 0 ? new Error(`${l} items failed`) : void 0,
+      {
+        ...n,
+        status: h.COMPLETED,
+        passed: u,
+        failed: l
+      }
+    ), c;
+  } catch (r) {
+    const o = e.map((i) => ({
+      path: i,
+      passed: !1,
+      reason: `Processing error: ${r.message}`
+    }));
+    return m(t, e, r, {
+      ...n,
+      status: h.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);
+  return {
+    passed: a,
+    failed: t,
+    allPassed: n,
+    stoppedEarly: r,
+    failures: o,
+    total: e.length,
+    processed: s.length
+  };
+}
+function j(e, s, a) {
+  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 ? `
+  ... and ${e.failures.length - g} more failures` : "";
+  return `${e.failed}/${e.processed} items failed: ${s}${e.stoppedEarly && a !== I ? ` (stopped after ${a} failures)` : ""}
+
+Failures:
+${t}${n}`;
+}
+function M(e, s) {
+  return {
+    passed: e.allPassed,
+    message: s,
+    details: {
+      total: e.total,
+      processed: e.processed,
+      passed: e.passed,
+      failed: e.failed,
+      failures: e.failures
+    }
+  };
+}
+function U(e, s, a, t) {
+  const n = s || a.length > 0 || t <= D;
+  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,
+      o,
+      i.description,
+      i.onProgress,
+      i.metadata
+    )
+  };
+}
+async function $(e, s, a) {
+  const t = e.items.map(
+    (n) => k(
+      n,
+      s,
+      a.itemContextFns,
+      a.description,
+      a.targetType
+    )
+  );
+  return await Promise.all(t);
+}
+function B(e, s, a) {
+  if (s === f.INDIVIDUAL) {
+    const { results: t, errors: n, failures: r, shouldStop: o } = L(
+      e,
+      a.isCoverageTest,
+      a.maxFailures,
+      a.currentFailures || 0
+    );
+    return {
+      results: t,
+      errors: n,
+      failures: r,
+      shouldStop: o,
+      progressData: {
+        passed: t.filter((i) => i.passed).length,
+        failed: n.length
+      }
+    };
+  } else {
+    const t = e.map((n) => ({
+      item: n.path,
+      passed: n.passed,
+      reason: n.reason
+    }));
+    return {
+      results: t,
+      errors: [],
+      failures: a.currentFailures || 0,
+      shouldStop: !1,
+      progressData: {
+        passed: t.filter((n) => n.passed).length,
+        failed: t.filter((n) => !n.passed).length
+      }
+    };
+  }
+}
+async function z(e, s, a, t) {
+  const n = O(e, a.batchSize), r = [];
+  let o = 0;
+  for (const i of n) {
+    if (!t.isCoverageTest && o >= t.maxFailures)
+      break;
+    const c = b(
+      i,
+      n.length,
+      e.length,
+      h.PROCESSING,
+      t,
+      a.mode
+    );
+    m(t.onChunkProcessed, i.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,
+      s,
+      t.description,
+      t.onChunkProcessed,
+      c
+    );
+    const u = B(l, a.mode, {
+      ...t,
+      currentFailures: o
+    });
+    if (r.push(...u.results), o = u.failures, m(
+      t.onChunkProcessed,
+      i.items,
+      u.errors.length > 0 ? u.errors[0] : void 0,
+      {
+        ...b(
+          i,
+          n.length,
+          e.length,
+          h.COMPLETED,
+          t,
+          a.mode
+        ),
+        ...u.progressData
+      }
+    ), u.shouldStop)
+      break;
+  }
+  return r;
+}
+const J = {
+  type: "object",
+  properties: {
+    passed: { type: "boolean" },
+    reason: { type: "string" }
+  },
+  required: ["passed", "reason"]
+}, G = {
+  type: "object",
+  properties: {
+    results: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          path: { type: "string" },
+          passed: { type: "boolean" },
+          reason: { type: "string" }
+        },
+        required: ["path", "passed", "reason"]
+      }
+    }
+  },
+  required: ["results"]
+};
+function E(e) {
+  switch (e.type) {
+    case "file":
+      return p.existsSync(e.filePath) ? `<${e.name}>
+${p.readFileSync(e.filePath, "utf8")}
+</${e.name}>` : "";
+    case "json": {
+      if (!p.existsSync(e.filePath)) return "";
+      const s = JSON.parse(p.readFileSync(e.filePath, "utf8"));
+      return `<${e.name}>
+${JSON.stringify(s, void 0, 2)}
+</${e.name}>`;
+    }
+    case "data": {
+      const s = typeof e.data == "string" ? e.data : JSON.stringify(e.data, void 0, 2);
+      return `<${e.name}>
+${s}
+</${e.name}>`;
+    }
+    default:
+      return "";
+  }
+}
+function V(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;
+  }
+}
+function q(e, s, a, t) {
+  const n = V(s);
+  return `${e}
+Analyze this ${t ? "file" : "directory"}: ${s}
+
+Content:
+${n}
+
+Does it satisfy: "${a}"?
+
+Return JSON with "passed" (boolean) and "reason" (string).`;
+}
+function H(e, s, a) {
+  return `${e}
+Analyze each item and determine if it satisfies: "${a}"
+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;
+  }
+  withContext(s) {
+    return this.contexts.push(s), this;
+  }
+  withItemContext(s) {
+    return this.itemContextFns.push(s), this;
+  }
+  // Set up for a satisfies test
+  satisfies(s) {
+    return this.description = s, this;
+  }
+  // Set up for a coverage test
+  coverage(s = _) {
+    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(`
+
+`), t = U(
+      this,
+      this.onChunkProcessed,
+      this.itemContextFns,
+      s.length
+    ), n = {
+      bulkSize: this.bulkSize,
+      maxConcurrency: this.maxConcurrency,
+      description: this.description,
+      onChunkProcessed: this.onChunkProcessed,
+      itemContextFns: this.itemContextFns,
+      targetType: this.target.type,
+      maxFailures: this.maxFailures,
+      isCoverageTest: this.isCoverageTest
+    }, r = await z(s, a, t, n);
+    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`;
+      if (!c)
+        throw new Error(l);
+      return { passed: c, coverage: i, message: l };
+    }
+    return this.summarize(s, r);
+  }
+  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);
+  }
+}
+function le(e, s = {}) {
+  return new X(e, s);
+}
+function ue() {
+  return console.warn("scanJS is not available in browser environment"), Promise.resolve({});
+}
+const W = {
+  name: "test_analysis_result",
+  schema: {
+    type: "object",
+    properties: {
+      hasIssues: {
+        type: "boolean",
+        description: "Whether any issues were found in the code analysis"
+      },
+      issues: {
+        type: "array",
+        description: "List of identified issues with the code",
+        items: {
+          type: "string",
+          description: "A specific issue with actionable feedback and line references where applicable"
+        }
+      }
+    },
+    required: ["hasIssues", "issues"],
+    additionalProperties: !1
+  }
+};
+async function d(e, s, a = {}) {
+  try {
+    const t = await F.readFile(e, "utf-8"), n = `Analyze this code and ${s}:
+
+${x(t, { tag: "code-to-analyze" })}
+
+Return a JSON object with:
+- "hasIssues": boolean indicating if any issues were found
+- "issues": array of strings, each describing a specific issue with actionable feedback
+
+GUIDELINES:
+- Focus only on issues related to the test criteria
+- 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
+        }
+      }
+    });
+    return r.hasIssues ? r.issues : [];
+  } catch (t) {
+    return [`Error analyzing ${e}: ${t.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),
+  ...await d(e, te),
+  ...await d(e, ae)
+];
+R.isNode && (await import("dotenv")).config();
+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,
+  d as test,
+  de as testAdvice,
+  Is as themes,
+  ws as timeline,
+  $s as toObject,
+  Es as truncate,
+  Ps as veiledVariants
+};