@lowgular/code-graph 0.0.1

package/libs/cli/shared/src/lib/infrastructure/http.js

@@ -0,0 +1,257 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var http_exports = {};
+__export(http_exports, {
+  AuthClient: () => AuthClient,
+  PlatformClient: () => PlatformClient
+});
+module.exports = __toCommonJS(http_exports);
+var http = __toESM(require("http"));
+var https = __toESM(require("https"));
+var import_utils = require("../utils/utils.js");
+const requestWithProtocol = function(protocol, options, body) {
+  (0, import_utils.verboseLog)(options);
+  return new Promise((resolve, reject) => {
+    const req = protocol.request(
+      options,
+      (res) => resolveResponse(res, resolve, reject)
+    );
+    req.on("error", reject);
+    if (body) {
+      req.write((0, import_utils.stringifyJSON)(body));
+    }
+    req.end();
+  });
+};
+const genericPost = function(protocol, hostname, path, body, headers, port) {
+  return requestWithProtocol(
+    protocol,
+    { method: "POST", hostname, path, headers, port },
+    body
+  );
+};
+const genericPut = function(protocol, hostname, path, body, headers, port) {
+  return requestWithProtocol(
+    protocol,
+    { method: "PUT", hostname, path, headers, port },
+    body
+  );
+};
+const genericPatch = function(protocol, hostname, path, body, headers, port) {
+  return requestWithProtocol(
+    protocol,
+    { method: "PATCH", hostname, path, headers, port },
+    body
+  );
+};
+const genericGet = function(protocol, hostname, path, headers, port) {
+  return requestWithProtocol(
+    protocol,
+    { method: "GET", hostname, path, headers, port },
+    void 0
+  );
+};
+function resolveResponse(res, resolve, reject) {
+  const chunks = [];
+  res.on("data", (data) => chunks.push(data));
+  res.on("end", () => {
+    let resBody = Buffer.concat(chunks);
+    let parsedBody;
+    switch (res.headers["content-type"]?.split(";")[0]) {
+      case "application/json":
+        parsedBody = JSON.parse(resBody.toString());
+        break;
+      default:
+        parsedBody = resBody.toString();
+    }
+    (0, import_utils.verboseLog)("Response Status:", res.statusCode);
+    (0, import_utils.verboseLog)("Response Headers:", res.headers);
+    (0, import_utils.verboseLog)("Response Body:", parsedBody);
+    if (res.statusCode === 403 && parsedBody.message === "Token is invalid") {
+      reject(
+        new Error(
+          `Token expired: Please run 'lg refresh' to refresh your token and try again.`
+        )
+      );
+    } else if (res.statusCode === 401 || res.statusCode === 403) {
+      reject(
+        new Error(
+          `Unauthorized: ${parsedBody.message || "Authentication failed"}`
+        )
+      );
+    } else if (res.statusCode >= 400 && res.statusCode < 500) {
+      const errorMessage = parsedBody.message || parsedBody.error || "Request failed";
+      reject(new Error(`Client Error (${res.statusCode}): ${errorMessage}`));
+    } else if (res.statusCode >= 500) {
+      const errorMessage = parsedBody.message || parsedBody.error || "Server error";
+      reject(new Error(`Server Error (${res.statusCode}): ${errorMessage}`));
+    } else {
+      resolve(parsedBody);
+    }
+  });
+}
+class JsonClient {
+  constructor() {
+    this.protocol = https;
+    this.headers = {
+      "Content-Type": "application/json"
+    };
+  }
+  get(path) {
+    return genericGet(
+      this.protocol,
+      this.hostname,
+      path,
+      this.headers,
+      this.port
+    );
+  }
+  put(path, body) {
+    return genericPut(
+      this.protocol,
+      this.hostname,
+      path,
+      body,
+      this.headers,
+      this.port
+    );
+  }
+  post(path, body) {
+    return genericPost(
+      this.protocol,
+      this.hostname,
+      path,
+      body,
+      this.headers,
+      this.port
+    );
+  }
+  patch(path, body) {
+    return genericPatch(
+      this.protocol,
+      this.hostname,
+      path,
+      body,
+      this.headers,
+      this.port
+    );
+  }
+}
+class PlatformClient extends JsonClient {
+  constructor(tokenManager, env = "prod") {
+    super();
+    this.tokenManager = tokenManager;
+    this.prefix = "";
+    if (env === "dev") {
+      this.hostname = "127.0.0.1";
+      this.port = 5001;
+      this.prefix = "/lowgular-platform-c0e93/us-central1";
+      this.protocol = http;
+    } else {
+      this.hostname = "us-central1-lowgular-platform-c0e93.cloudfunctions.net";
+      this.protocol = https;
+    }
+  }
+  setTokenHeader() {
+    this.headers.Authorization = `Bearer ${this.tokenManager.readAccessToken()}`;
+  }
+  async interceptTokenError(req) {
+    try {
+      this.setTokenHeader();
+      return await req();
+    } catch (error) {
+      if (error.message.includes("Token expired")) {
+        await this.tokenManager.refreshToken();
+        this.setTokenHeader();
+        return await req();
+      }
+      throw error;
+    }
+  }
+  get(path) {
+    return this.interceptTokenError(
+      () => genericGet(
+        this.protocol,
+        this.hostname,
+        this._fullPath(path),
+        this.headers,
+        this.port
+      )
+    );
+  }
+  put(path, body) {
+    return this.interceptTokenError(
+      () => genericPut(
+        this.protocol,
+        this.hostname,
+        this._fullPath(path),
+        body,
+        this.headers,
+        this.port
+      )
+    );
+  }
+  post(path, body) {
+    return this.interceptTokenError(
+      () => genericPost(
+        this.protocol,
+        this.hostname,
+        this._fullPath(path),
+        body,
+        this.headers,
+        this.port
+      )
+    );
+  }
+  patch(path, body) {
+    return this.interceptTokenError(
+      () => genericPatch(
+        this.protocol,
+        this.hostname,
+        this._fullPath(path),
+        body,
+        this.headers,
+        this.port
+      )
+    );
+  }
+  _fullPath(path) {
+    return this.prefix ? `${this.prefix}${path}` : path;
+  }
+}
+class AuthClient extends JsonClient {
+  constructor() {
+    super(...arguments);
+    this.hostname = "us-central1-lowgular-extension.cloudfunctions.net";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthClient,
+  PlatformClient
+});

package/libs/cli/shared/src/lib/infrastructure/markdown.js

@@ -0,0 +1,95 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var markdown_exports = {};
+__export(markdown_exports, {
+  appendMarkdownMetadata: () => appendMarkdownMetadata,
+  cleanupBlocks: () => cleanupBlocks,
+  extractBlocks: () => extractBlocks,
+  extractMarkdownContent: () => extractMarkdownContent,
+  extractMarkdownMetadata: () => extractMarkdownMetadata,
+  parseMarkdownFile: () => parseMarkdownFile,
+  replaceMarkdownInclude: () => replaceMarkdownInclude
+});
+module.exports = __toCommonJS(markdown_exports);
+var import_yaml = require("./yaml");
+const metadataRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+const extractMarkdownMetadata = (markdown) => {
+  const metadata = markdown.match(metadataRegex)[1];
+  if (!metadata) {
+    return void 0;
+  }
+  return (0, import_yaml.parseTopLevelYamlStringsAndArrays)(metadata);
+};
+const extractMarkdownContent = (markdown) => {
+  const content = markdown.match(
+    /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/
+  )?.[2];
+  if (!content) {
+    throw new Error("No content found after metadata in README.md");
+  }
+  return content.trim();
+};
+function extractBlocks(markdown) {
+  const results = [];
+  const fence = /(^|[\r\n])```([^\n]*)\n([\s\S]*?)\n?```/g;
+  let match;
+  while (match = fence.exec(markdown)) {
+    const info = (match[2] || "").trim();
+    const type = (info.split(/\s+/)[0] || "text").trim();
+    const content = (match[3] || "").replace(/\s+$/, "");
+    results.push({ type, content });
+  }
+  return results;
+}
+function cleanupBlocks(markdown) {
+  return markdown.replace(/(^|[\r\n])```([^\n]*)\n([\s\S]*?)\n```/g, "");
+}
+const parseMarkdownFile = (markdown) => {
+  if (markdown.match(metadataRegex) !== null) {
+    return {
+      metadata: extractMarkdownMetadata(markdown),
+      content: extractMarkdownContent(markdown)
+    };
+  }
+  return {
+    metadata: {},
+    content: markdown
+  };
+};
+const appendMarkdownMetadata = (markdown, metadata) => {
+  return `---${Object.entries(metadata).map(([key, value]) => `${key}: ${value}`).join("\n")}---
+${markdown}`;
+};
+const replaceMarkdownInclude = (markdown, fileSystem) => {
+  return markdown.replace(/<!--\s*include:\s*(.+?)\s*-->/g, (match, p1) => {
+    if (p1 in fileSystem) {
+      return fileSystem[p1];
+    }
+    return match;
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendMarkdownMetadata,
+  cleanupBlocks,
+  extractBlocks,
+  extractMarkdownContent,
+  extractMarkdownMetadata,
+  parseMarkdownFile,
+  replaceMarkdownInclude
+});

package/libs/cli/shared/src/lib/infrastructure/transformers/embeddings.js

@@ -0,0 +1,88 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var embeddings_exports = {};
+__export(embeddings_exports, {
+  embedText: () => embedText,
+  embedTexts: () => embedTexts
+});
+module.exports = __toCommonJS(embeddings_exports);
+var import_transformers = require("@huggingface/transformers");
+const SMALL_MODEL_ID = "Xenova/bge-small-en-v1.5";
+const BASE_MODEL_ID = "Xenova/bge-base-en-v1.5";
+let smallExtractor;
+let baseExtractor;
+async function getExtractor(size = "small") {
+  if (size === "small") {
+    if (!smallExtractor) {
+      smallExtractor = await (0, import_transformers.pipeline)("feature-extraction", SMALL_MODEL_ID, {
+        dtype: "fp32"
+      });
+    }
+    return smallExtractor;
+  } else {
+    if (!baseExtractor) {
+      baseExtractor = await (0, import_transformers.pipeline)("feature-extraction", BASE_MODEL_ID, {
+        dtype: "fp32"
+      });
+    }
+    return baseExtractor;
+  }
+}
+function toRows(out) {
+  if (out?.data && out?.dims) {
+    const [batchSize, dim] = out.dims;
+    const data = Array.from(out.data);
+    const rows = [];
+    for (let i = 0; i < batchSize; i++) {
+      rows.push(data.slice(i * dim, (i + 1) * dim));
+    }
+    return rows;
+  }
+  const d = out?.data ?? out;
+  if (!d)
+    throw new Error("embed: output has no data");
+  if (ArrayBuffer.isView(d))
+    return [Array.from(d)];
+  if (Array.isArray(d)) {
+    if (d.length > 0 && Array.isArray(d[0])) {
+      return d;
+    }
+    return [d];
+  }
+  throw new Error(
+    `embed: unknown output shape - ${JSON.stringify({ type: typeof out, hasData: !!out?.data, hasDims: !!out?.dims })}`
+  );
+}
+async function embedTexts(texts, size = "small") {
+  if (!texts?.length)
+    throw new Error("embedTexts: texts is empty");
+  const ex = await getExtractor(size);
+  const raw = await ex(texts, { pooling: "mean", normalize: true });
+  const rows = toRows(raw);
+  const dim = rows[0].length;
+  return rows.map((v) => Float32Array.from(v));
+}
+async function embedText(text, size = "small") {
+  const [v] = await embedTexts([text], size);
+  return Array.from(v);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  embedText,
+  embedTexts
+});

package/libs/cli/shared/src/lib/infrastructure/transformers/index.js

@@ -0,0 +1,25 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transformers_exports = {};
+module.exports = __toCommonJS(transformers_exports);
+__reExport(transformers_exports, require("./embeddings"), module.exports);
+__reExport(transformers_exports, require("./rag-eval"), module.exports);
+__reExport(transformers_exports, require("./similarity"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./embeddings"),
+  ...require("./rag-eval"),
+  ...require("./similarity")
+});

package/libs/cli/shared/src/lib/infrastructure/transformers/rag-eval.js

@@ -0,0 +1,154 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rag_eval_exports = {};
+__export(rag_eval_exports, {
+  aggregateRAGMetrics: () => aggregateRAGMetrics,
+  evaluateRAG: () => evaluateRAG,
+  formatRAGEvaluationResults: () => formatRAGEvaluationResults,
+  precisionAtK: () => precisionAtK,
+  recallAtK: () => recallAtK,
+  validateNaming: () => validateNaming
+});
+module.exports = __toCommonJS(rag_eval_exports);
+var import_similarity = require("./similarity");
+async function validateNaming(userInput, expectedNames) {
+  if (!userInput?.trim()) {
+    throw new Error("userInput is empty");
+  }
+  if (!expectedNames?.length) {
+    throw new Error("expectedNames is empty");
+  }
+  const stringScores = expectedNames.map((expected) => ({
+    name: expected,
+    score: (0, import_similarity.stringSimilarity)(userInput, expected)
+  }));
+  const semanticResults = await (0, import_similarity.findSimilarWords)(
+    userInput,
+    expectedNames,
+    expectedNames.length
+    // Get all results
+  );
+  const combinedScores = expectedNames.map((expected) => {
+    const semantic = semanticResults.find((r) => r.word === expected)?.similarity ?? 0;
+    const string = stringScores.find((s) => s.name === expected)?.score ?? 0;
+    const combined = semantic * 0.6 + string * 0.4;
+    return {
+      name: expected,
+      semantic,
+      string,
+      combined
+    };
+  });
+  const bestMatch = combinedScores.reduce(
+    (max, curr) => curr.combined > max.combined ? curr : max
+  );
+  return {
+    bestMatch: bestMatch.name,
+    similarity: bestMatch.combined,
+    semanticScore: bestMatch.semantic,
+    stringScore: bestMatch.string
+  };
+}
+function precisionAtK(relevantCount, k) {
+  if (relevantCount < 0 || k < 0) {
+    throw new Error("All input values must be non-negative");
+  }
+  if (k === 0) {
+    return 0;
+  }
+  return relevantCount / k;
+}
+function recallAtK(relevantCount, totalRelevant) {
+  if (relevantCount < 0 || totalRelevant < 0) {
+    throw new Error("All input values must be non-negative");
+  }
+  if (totalRelevant === 0) {
+    return 0;
+  }
+  return relevantCount / totalRelevant;
+}
+function evaluateRAG(queries, searchResults, options) {
+  const results = [];
+  for (const queryItem of queries) {
+    const { query, relevantDocumentIds } = queryItem;
+    const retrievedIds = searchResults.map((r) => r.id);
+    const relevantFound = retrievedIds.filter(
+      (id) => relevantDocumentIds.includes(id)
+    ).length;
+    const precision = precisionAtK(relevantFound, options.topK);
+    const recall = recallAtK(relevantFound, relevantDocumentIds.length);
+    results.push({
+      query,
+      precisionAtK: precision,
+      recallAtK: recall,
+      relevantFound,
+      totalRelevant: relevantDocumentIds.length,
+      retrievedIds
+    });
+  }
+  return results;
+}
+function aggregateRAGMetrics(results) {
+  if (results.length === 0) {
+    return {
+      meanPrecision: 0,
+      meanRecall: 0,
+      totalQueries: 0,
+      averageRelevantFound: 0,
+      averageTotalRelevant: 0
+    };
+  }
+  const meanPrecision = results.reduce((sum, r) => sum + r.precisionAtK, 0) / results.length;
+  const meanRecall = results.reduce((sum, r) => sum + r.recallAtK, 0) / results.length;
+  const averageRelevantFound = results.reduce((sum, r) => sum + r.relevantFound, 0) / results.length;
+  const averageTotalRelevant = results.reduce((sum, r) => sum + r.totalRelevant, 0) / results.length;
+  return {
+    meanPrecision,
+    meanRecall,
+    totalQueries: results.length,
+    averageRelevantFound,
+    averageTotalRelevant
+  };
+}
+function formatRAGEvaluationResults(results, k) {
+  const lines = [];
+  lines.push("=".repeat(80));
+  lines.push(`Results with K=${k}:`);
+  lines.push("=".repeat(80));
+  for (const result of results) {
+    lines.push(`Query: ${result.query}`);
+    lines.push(`  Retrieved: ${result.retrievedIds.length}`);
+    lines.push(
+      `  Precision@${k}: ${result.precisionAtK.toFixed(2)}, Recall@${k}: ${result.recallAtK.toFixed(2)}`
+    );
+    lines.push(
+      `  Relevant found: ${result.relevantFound}/${result.totalRelevant}`
+    );
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  aggregateRAGMetrics,
+  evaluateRAG,
+  formatRAGEvaluationResults,
+  precisionAtK,
+  recallAtK,
+  validateNaming
+});