@lowgular/code-graph 0.0.1 → 0.1.2

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

@@ -1,210 +0,0 @@
-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 similarity_exports = {};
-__export(similarity_exports, {
-  calcSimilarity: () => calcSimilarity,
-  calcSimilarityForEach: () => calcSimilarityForEach,
-  findSimilarWords: () => findSimilarWords,
-  stringSimilarity: () => stringSimilarity
-});
-module.exports = __toCommonJS(similarity_exports);
-var import_transformers = require("../transformers");
-const mean = (vecs) => {
-  if (!vecs.length)
-    throw new Error("mean([])");
-  if (!vecs[0])
-    throw new Error("mean: vecs[0] is undefined");
-  const d = vecs[0].length;
-  if (!d)
-    throw new Error("mean: vecs[0].length is 0");
-  const out = new Float32Array(d);
-  for (const v of vecs) {
-    if (!v)
-      throw new Error("mean: found undefined vector");
-    if (v.length !== d)
-      throw new Error(
-        `mean: dimension mismatch - expected ${d}, got ${v.length}`
-      );
-    for (let i = 0; i < d; i++)
-      out[i] += v[i];
-  }
-  for (let i = 0; i < d; i++)
-    out[i] /= vecs.length;
-  return out;
-};
-const cos = (a, b) => {
-  if (!a || !b) {
-    throw new Error(`cos: invalid inputs - a: ${!!a}, b: ${!!b}`);
-  }
-  if (a.length !== b.length) {
-    throw new Error(`cos: dimension mismatch - a: ${a.length}, b: ${b.length}`);
-  }
-  let s = 0;
-  for (let i = 0; i < a.length; i++)
-    s += a[i] * b[i];
-  return s;
-};
-async function calcSimilarity(SEEDS, tokens) {
-  if (!SEEDS?.length)
-    throw new Error("SEEDS empty");
-  if (!tokens?.length)
-    tokens = [""];
-  const seedVecs = await (0, import_transformers.embedTexts)(SEEDS);
-  if (seedVecs.length !== SEEDS.length) {
-    throw new Error(
-      `seedVecs length mismatch: expected ${SEEDS.length}, got ${seedVecs.length}`
-    );
-  }
-  if (seedVecs.some((v) => !v)) {
-    throw new Error("seedVecs contains undefined/null values");
-  }
-  const seedCentroid = mean(seedVecs);
-  const tokVecs = await (0, import_transformers.embedTexts)(tokens);
-  if (!tokVecs.length) {
-    throw new Error("tokVecs is empty");
-  }
-  const nameVec = mean(tokVecs);
-  const perSeed = SEEDS.map((w, i) => {
-    const vec = seedVecs[i];
-    if (!vec) {
-      throw new Error(`seedVecs[${i}] is undefined for seed "${w}"`);
-    }
-    return {
-      word: w,
-      sim: cos(nameVec, vec)
-    };
-  }).sort((a, b) => b.sim - a.sim);
-  const centroidSim = cos(nameVec, seedCentroid);
-  const best = Math.max(centroidSim, perSeed[0]?.sim ?? -1);
-  return { best, centroidSim, perSeed };
-}
-async function calcSimilarityForEach(SEEDS, tokens) {
-  if (!SEEDS?.length)
-    throw new Error("SEEDS empty");
-  if (!tokens?.length)
-    throw new Error("tokens empty");
-  const seedVecs = await (0, import_transformers.embedTexts)(SEEDS);
-  if (seedVecs.length !== SEEDS.length) {
-    throw new Error(
-      `seedVecs length mismatch: expected ${SEEDS.length}, got ${seedVecs.length}`
-    );
-  }
-  if (seedVecs.some((v) => !v)) {
-    throw new Error("seedVecs contains undefined/null values");
-  }
-  const tokVecs = await (0, import_transformers.embedTexts)(tokens);
-  if (tokVecs.length !== tokens.length) {
-    throw new Error(
-      `tokVecs length mismatch: expected ${tokens.length}, got ${tokVecs.length}`
-    );
-  }
-  if (tokVecs.some((v) => !v)) {
-    throw new Error("tokVecs contains undefined/null values");
-  }
-  const result = {};
-  for (let i = 0; i < SEEDS.length; i++) {
-    const seedWord = SEEDS[i];
-    const seedVec = seedVecs[i];
-    if (!seedVec) {
-      throw new Error(`seedVecs[${i}] is undefined for seed "${seedWord}"`);
-    }
-    const similarities = [];
-    for (let j = 0; j < tokens.length; j++) {
-      const token = tokens[j];
-      const tokenVec = tokVecs[j];
-      if (!tokenVec) {
-        throw new Error(`tokVecs[${j}] is undefined for token "${token}"`);
-      }
-      similarities.push({
-        key: token,
-        value: cos(seedVec, tokenVec)
-      });
-    }
-    result[seedWord] = similarities;
-  }
-  return result;
-}
-async function findSimilarWords(context, vocabulary, topK = 5) {
-  if (!context?.trim())
-    throw new Error("context is empty");
-  if (!vocabulary?.length)
-    throw new Error("vocabulary is empty");
-  const [contextVec] = await (0, import_transformers.embedTexts)([context]);
-  const vocabVecs = await (0, import_transformers.embedTexts)(vocabulary);
-  if (vocabVecs.length !== vocabulary.length) {
-    throw new Error(
-      `vocabVecs length mismatch: expected ${vocabulary.length}, got ${vocabVecs.length}`
-    );
-  }
-  const similarities = [];
-  for (let i = 0; i < vocabulary.length; i++) {
-    const word = vocabulary[i];
-    const wordVec = vocabVecs[i];
-    if (!wordVec) {
-      throw new Error(`vocabVecs[${i}] is undefined for word "${word}"`);
-    }
-    similarities.push({
-      word,
-      similarity: cos(contextVec, wordVec)
-    });
-  }
-  return similarities.sort((a, b) => b.similarity - a.similarity).slice(0, topK);
-}
-function stringSimilarity(a, b) {
-  const maxLen = Math.max(a.length, b.length);
-  if (maxLen === 0)
-    return 1;
-  const normalizedA = a.toLowerCase();
-  const normalizedB = b.toLowerCase();
-  const distance = levenshteinDistance(normalizedA, normalizedB);
-  return 1 - distance / maxLen;
-}
-function levenshteinDistance(a, b) {
-  if (a.length === 0)
-    return b.length;
-  if (b.length === 0)
-    return a.length;
-  const matrix = [];
-  for (let i = 0; i <= b.length; i++) {
-    matrix[i] = [i];
-  }
-  for (let j = 0; j <= a.length; j++) {
-    matrix[0][j] = j;
-  }
-  for (let i = 1; i <= b.length; i++) {
-    for (let j = 1; j <= a.length; j++) {
-      if (b.charAt(i - 1) === a.charAt(j - 1)) {
-        matrix[i][j] = matrix[i - 1][j - 1];
-      } else {
-        matrix[i][j] = Math.min(
-          matrix[i - 1][j - 1] + 1,
-          matrix[i][j - 1] + 1,
-          matrix[i - 1][j] + 1
-        );
-      }
-    }
-  }
-  return matrix[b.length][a.length];
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  calcSimilarity,
-  calcSimilarityForEach,
-  findSimilarWords,
-  stringSimilarity
-});

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

@@ -1,297 +0,0 @@
-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 workspace_exports = {};
-__export(workspace_exports, {
-  cleanupWorkspace: () => cleanupWorkspace,
-  clearLeadingRelativePath: () => clearLeadingRelativePath,
-  copyFile: () => copyFile,
-  createFiles: () => createFiles,
-  createWorkspace: () => createWorkspace,
-  deepFindFile: () => deepFindFile,
-  filterOutByGitIgnore: () => filterOutByGitIgnore,
-  filterOutFolders: () => filterOutFolders,
-  findAllTestsInSubfolder: () => findAllTestsInSubfolder,
-  findFilesInSubfolder: () => findFilesInSubfolder,
-  findTests: () => findTests,
-  getDiffReport: () => getDiffReport,
-  getLatestModifiedFile: () => getLatestModifiedFile,
-  getSubfolders: () => getSubfolders,
-  listDirectories: () => listDirectories,
-  readAllSnapshots: () => readAllSnapshots,
-  readGitIgnore: () => readGitIgnore,
-  readPaths: () => readPaths,
-  readWorkspace: () => readWorkspace,
-  recreateSubFolder: () => recreateSubFolder,
-  recreateWorkspace: () => recreateWorkspace,
-  removeAllFiles: () => removeAllFiles
-});
-module.exports = __toCommonJS(workspace_exports);
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var import_utils = require("../utils/utils.js");
-var import_git = require("./git.js");
-function deepFindFile(dir, fileName, fileList = []) {
-  const files = fs.readdirSync(dir, { withFileTypes: true });
-  for (const file of files) {
-    const filePath = path.join(dir, file.name);
-    if (file.isDirectory()) {
-      deepFindFile(filePath, fileName, fileList);
-    } else if (file.name === fileName) {
-      const stats = fs.statSync(filePath);
-      fileList.push({
-        path: filePath,
-        mtime: stats.mtime
-      });
-    }
-  }
-  return fileList;
-}
-function getLatestModifiedFile(files) {
-  if (files.length === 0) {
-    (0, import_utils.verboseLog)("No assessment.json files found in report directory");
-    return null;
-  }
-  files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-  (0, import_utils.verboseLog)(`Found ${files.length} assessment file(s), using latest: ${files[0].path}`);
-  return files[0].path;
-}
-function cleanupWorkspace(folderName) {
-  const files = readWorkspace(folderName);
-  (0, import_utils.verboseLog)("Cleaning up the files...", Object.keys(files));
-  Object.keys(files).forEach((filePath) => {
-    fs.unlinkSync(filePath);
-  });
-}
-function findTests(fs2) {
-  return Object.keys(fs2).reduce(
-    (a, f) => f.match(new RegExp(`.spec.ts$`)) ? { ...a, [f]: fs2[f] } : a,
-    {}
-  );
-}
-function findFilesInSubfolder(folderPath, fs2) {
-  const folder = (0, import_utils.escapeRegExp)(
-    folderPath.endsWith("/") ? folderPath : folderPath + "/"
-  );
-  return Object.keys(fs2).reduce(
-    (a, f) => f.match(new RegExp(`^${folder}`)) ? { ...a, [f]: fs2[f] } : a,
-    {}
-  );
-}
-function findAllTestsInSubfolder(folderPath, files) {
-  return Object.keys(findTests(findFilesInSubfolder(folderPath, files)));
-}
-function removeAllFiles(paths) {
-  paths.forEach((p) => fs.unlinkSync(p));
-}
-function copyFile(src, dest) {
-  fs.copyFileSync(src, dest);
-}
-function filterOutFolders(files, folders) {
-  return Object.fromEntries(
-    Object.entries(files).filter(
-      ([k]) => !folders.some((f) => k.startsWith(f))
-    )
-  );
-}
-function filterOutByGitIgnore(files) {
-  const allRules = (0, import_git.collectAllGitIgnoreRules)(files);
-  if (allRules.length === 0) {
-    return files;
-  }
-  return Object.fromEntries(
-    Object.entries(files).filter(([filePath]) => {
-      return !(0, import_git.isIgnored)(filePath, allRules);
-    })
-  );
-}
-function recreateSubFolder(folderName) {
-  if (fs.existsSync(`${folderName}`)) {
-    fs.rmSync(`${folderName}`, { recursive: true, force: true });
-  }
-  fs.mkdirSync(`${folderName}`, { recursive: true });
-}
-function createFiles(filesJson) {
-  Object.keys(filesJson).forEach((filePath) => {
-    const dirname = path.dirname(filePath);
-    if (!fs.existsSync(`${dirname}`)) {
-      fs.mkdirSync(`${dirname}`, { recursive: true });
-    }
-    fs.writeFileSync(`${filePath}`, filesJson[filePath], {
-      flag: "w"
-    });
-  });
-}
-function createWorkspace(folderName, filesJson) {
-  const cleanFolderName = folderName.endsWith("/") ? folderName : folderName + "/";
-  (0, import_utils.verboseLog)("Creating workspace...", cleanFolderName, Object.keys(filesJson));
-  Object.keys(filesJson).forEach((filePath) => {
-    const dirname = path.dirname(filePath);
-    if (!fs.existsSync(`${cleanFolderName}${dirname}`)) {
-      fs.mkdirSync(`${cleanFolderName}${dirname}`, { recursive: true });
-    }
-    fs.writeFileSync(`${cleanFolderName}${filePath}`, filesJson[filePath], {
-      flag: "w"
-    });
-  });
-}
-function getDiffReport(currentFiles, newFiles) {
-  const currentFilePaths = Object.keys(currentFiles);
-  const newFilePaths = Object.keys(newFiles);
-  const changes = [];
-  newFilePaths.forEach((filePath) => {
-    if (!(filePath in currentFiles)) {
-      changes.push({ path: filePath, status: "added" });
-    } else if (currentFiles[filePath] !== newFiles[filePath]) {
-      changes.push({ path: filePath, status: "modified" });
-    }
-  });
-  currentFilePaths.forEach((filePath) => {
-    if (!(filePath in newFiles)) {
-      changes.push({ path: filePath, status: "deleted" });
-    }
-  });
-  return changes.sort((a, b) => a.path.localeCompare(b.path));
-}
-function recreateWorkspace(folderName, newFiles, foldersToKeep) {
-  const foldersToKeepRegexp = new RegExp(`^(${foldersToKeep.join("|")})`);
-  console.log("foldersToKeepRegexp", foldersToKeepRegexp);
-  const files = fs.readdirSync(folderName);
-  files.forEach((file) => {
-    console.log("file", file);
-    if (file.match(foldersToKeepRegexp) !== null) {
-      console.log("keeping", file);
-      return;
-    }
-    const filePath = path.join(folderName, file);
-    fs.rmSync(filePath, { recursive: true, force: true });
-  });
-  createWorkspace(folderName, newFiles);
-}
-function getSubfolders(dir) {
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-}
-const clearLeadingRelativePath = (path2) => {
-  return path2.replace(/^\.\//, "");
-};
-function readWorkspace(folderName, globalIgnore = []) {
-  if (!fs.existsSync(folderName)) {
-    throw new Error(`Folder ${folderName} does not exist.`);
-  }
-  const ignore = readGitIgnore(folderName);
-  const filePaths = readPaths(folderName, [...ignore, ...globalIgnore]);
-  const files = filePaths.reduce((a, c) => {
-    try {
-      return {
-        ...a,
-        [c.replace(folderName + "/", "")]: fs.readFileSync(c, "utf-8")
-      };
-    } catch (e) {
-      console.log("reading error", e);
-    }
-    return a;
-  }, {});
-  return files;
-}
-function readAllSnapshots(folder) {
-  return fs.readdirSync(folder, { withFileTypes: true }).reduce((a, c) => {
-    if (c.isFile()) {
-      a[c.name] = fs.readFileSync(`${c.path}/${c.name}`).toString("base64");
-    }
-    return a;
-  }, {});
-}
-function listDirectories(root) {
-  const entries = fs.readdirSync(root, { withFileTypes: true });
-  return entries.filter((e) => e.isDirectory()).map((e) => e.name);
-}
-function readPaths(folderName, ignore) {
-  return fs.readdirSync(folderName, { withFileTypes: true }).reduce((acc, p) => {
-    const path2 = p.parentPath ? `${p.parentPath}/${p.name}` : `${folderName}/${p.name}`;
-    if (ignore.some((i) => path2.includes(i))) {
-      return acc;
-    }
-    if (p.isFile()) {
-      return [
-        ...acc,
-        p.parentPath ? `${p.parentPath}/${p.name}` : `${folderName}/${p.name}`
-      ];
-    }
-    return [...acc, ...readPaths(`${folderName}/${p.name}`, ignore)];
-  }, []);
-}
-const DEFAULT_IGNORE = [
-  "node_modules/",
-  "package-lock.json",
-  ".angular/",
-  "__MAC/",
-  ".git/",
-  ".vscode/",
-  ".DS_Store/"
-];
-function readGitIgnore(folderName) {
-  try {
-    const gitIgnoreFile = fs.readFileSync(`${folderName}/.gitignore`, "utf-8");
-    if (!gitIgnoreFile) {
-      return DEFAULT_IGNORE;
-    }
-    return [
-      .../* @__PURE__ */ new Set([
-        ...DEFAULT_IGNORE,
-        ...gitIgnoreFile.split(/\r?\n/).filter((i) => !!i)
-      ])
-    ];
-  } catch (e) {
-    return DEFAULT_IGNORE;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  cleanupWorkspace,
-  clearLeadingRelativePath,
-  copyFile,
-  createFiles,
-  createWorkspace,
-  deepFindFile,
-  filterOutByGitIgnore,
-  filterOutFolders,
-  findAllTestsInSubfolder,
-  findFilesInSubfolder,
-  findTests,
-  getDiffReport,
-  getLatestModifiedFile,
-  getSubfolders,
-  listDirectories,
-  readAllSnapshots,
-  readGitIgnore,
-  readPaths,
-  readWorkspace,
-  recreateSubFolder,
-  recreateWorkspace,
-  removeAllFiles
-});