@massa-ai/tools-api 1.9.0 → 1.9.1

package/dist/index.js

@@ -938,6 +938,20 @@ function validateCapturePolicyConfig(raw2) {
     ...p.maxIgnorePatterns !== undefined && { maxIgnorePatterns: p.maxIgnorePatterns }
   };
 }
+function validateAllowedExtensionsConfig(raw2) {
+  if (!Array.isArray(raw2)) {
+    throw new TypeError("security.allowedExtensions must be an array of strings");
+  }
+  if (raw2.length === 0) {
+    throw new TypeError("security.allowedExtensions must not be empty \u2014 an empty allow-list indexes nothing; omit the key to use the defaults");
+  }
+  for (const ext of raw2) {
+    if (typeof ext !== "string" || !ext.startsWith(".") || ext.length < 2) {
+      throw new TypeError(`security.allowedExtensions[] must be dot-prefixed extensions (got ${JSON.stringify(ext)})`);
+    }
+  }
+  return [...raw2];
+}
 function getGlobalDataDir() {
   const envOverride = process.env.MASSA_AI_DATA_DIR;
   if (envOverride && envOverride.trim())
@@ -1233,7 +1247,7 @@ var init_config = __esm(() => {
       sanitizeInputs: process.env.SANITIZE_INPUTS !== "false",
       maxIndexSize: 1e5,
       maxFileSize: 1024 * 1024,
-      allowedExtensions: [...DEFAULT_ALLOWED_EXTENSIONS],
+      allowedExtensions: fileConfig.security?.allowedExtensions ? validateAllowedExtensionsConfig(fileConfig.security.allowedExtensions) : [...DEFAULT_ALLOWED_EXTENSIONS],
       excludePatterns: [
         "node_modules/**",
         ".git/**",
@@ -106605,14 +106619,140 @@ var require_ignore = __commonJS((exports, module) => {
 });
 
 // ../../packages/core/dist/services/search/capture-policy.js
-var regexCache;
+function globToRegex(pattern) {
+  let re = "^";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        re += ".*";
+        i += 2;
+        if (pattern[i] === "/")
+          i += 1;
+      } else {
+        re += "[^/]*";
+        i += 1;
+      }
+    } else if (ch === "?") {
+      re += "[^/]";
+      i += 1;
+    } else if (ch === ".") {
+      re += "\\.";
+      i += 1;
+    } else if ("+()^${}|[]\\".includes(ch)) {
+      re += "\\" + ch;
+      i += 1;
+    } else {
+      re += ch;
+      i += 1;
+    }
+  }
+  re += "$";
+  return new RegExp(re);
+}
+function validatePolicy(policy, opts = {}) {
+  if (!policy || typeof policy !== "object")
+    throw new TypeError("policy must be an object");
+  const p = policy;
+  const allowedKeys = new Set(["rules", "maxMatchWork", "maxIgnorePatterns"]);
+  if (opts.denyUnknownFields) {
+    for (const key of Object.keys(p)) {
+      if (!allowedKeys.has(key)) {
+        throw new TypeError(`policy: unknown field "${key}" (denyUnknownFields=true)`);
+      }
+    }
+  }
+  if (!Array.isArray(p.rules))
+    throw new TypeError("policy.rules must be an array");
+  const dropCount = p.rules.filter((r2) => r2?.disposition === "Drop").length;
+  const maxIgnore = typeof p.maxIgnorePatterns === "number" ? p.maxIgnorePatterns : MAX_IGNORE_PATTERNS2;
+  if (dropCount > maxIgnore) {
+    throw new TypeError(`policy: ${dropCount} Drop rules exceed maxIgnorePatterns=${maxIgnore}`);
+  }
+  if (p.maxMatchWork !== undefined) {
+    if (typeof p.maxMatchWork !== "number" || p.maxMatchWork < 0) {
+      throw new TypeError("policy.maxMatchWork must be a non-negative number");
+    }
+  }
+}
+function matchesGlob(path8, pattern) {
+  let re = regexCache.get(pattern);
+  if (!re) {
+    re = globToRegex(pattern);
+    regexCache.set(pattern, re);
+  }
+  return re.test(path8);
+}
+var MAX_MATCH_WORK = 1e5, MAX_IGNORE_PATTERNS2 = 1024, DEFAULT_POLICY, applyPolicy = (filePath, policy) => {
+  const normalized = filePath.trim();
+  for (const rule of policy.rules) {
+    if (matchesGlob(normalized, rule.pattern))
+      return rule.disposition;
+  }
+  return "Keep";
+}, regexCache;
 var init_capture_policy = __esm(() => {
+  DEFAULT_POLICY = {
+    rules: [
+      { pattern: "**/node_modules/**", disposition: "Drop" },
+      { pattern: "**/.git/**", disposition: "Drop" },
+      { pattern: "**/dist/**", disposition: "Drop" },
+      { pattern: "**/build/**", disposition: "Drop" },
+      { pattern: "**/coverage/**", disposition: "Drop" },
+      { pattern: ".env", disposition: "Drop" },
+      { pattern: ".env.*", disposition: "Drop" },
+      { pattern: "**/generated/**", disposition: "Drop" },
+      { pattern: "**/*.generated.*", disposition: "Drop" },
+      { pattern: "**/*.d.ts", disposition: "Drop" },
+      { pattern: "**/__tests__/**", disposition: "Drop" },
+      { pattern: "**/tests/**", disposition: "Drop" },
+      { pattern: "**/*.test.ts", disposition: "Drop" },
+      { pattern: "**/*.test.tsx", disposition: "Drop" },
+      { pattern: "**/*.test.js", disposition: "Drop" },
+      { pattern: "**/*.test.jsx", disposition: "Drop" },
+      { pattern: "**/*.spec.ts", disposition: "Drop" },
+      { pattern: "**/*.spec.tsx", disposition: "Drop" },
+      { pattern: "**/*.spec.js", disposition: "Drop" },
+      { pattern: "**/*.spec.jsx", disposition: "Drop" },
+      { pattern: "**/benchmarks/**", disposition: "Drop" },
+      { pattern: "**/fixtures/**", disposition: "Drop" },
+      { pattern: "**/*.wasm*", disposition: "Drop" },
+      { pattern: "**/*.min.*", disposition: "Drop" },
+      { pattern: "**/*.map", disposition: "Drop" },
+      { pattern: "**/lock.yaml", disposition: "Drop" },
+      { pattern: "**/pnpm-lock.yaml", disposition: "Drop" },
+      { pattern: "**/package-lock.json", disposition: "Drop" },
+      { pattern: "**/bun.lockb", disposition: "Drop" },
+      { pattern: "**/yarn.lock", disposition: "Drop" }
+    ],
+    maxMatchWork: MAX_MATCH_WORK,
+    maxIgnorePatterns: MAX_IGNORE_PATTERNS2
+  };
   regexCache = new Map;
 });
 
 // ../../packages/core/dist/services/search/ignore-patterns.js
 import fs3 from "fs/promises";
 import path8 from "path";
+function buildExtensionGlob(extensions2) {
+  return extensions2.map((ext2) => `**/*${ext2}`);
+}
+function getActivePolicy() {
+  if (cachedPolicy)
+    return cachedPolicy;
+  const fromConfig = config.get("capturePolicy");
+  if (!fromConfig) {
+    cachedPolicy = DEFAULT_POLICY;
+    return cachedPolicy;
+  }
+  validatePolicy(fromConfig, { denyUnknownFields: true });
+  cachedPolicy = fromConfig;
+  return cachedPolicy;
+}
+function getActiveCapturePolicy() {
+  return getActivePolicy();
+}
 async function loadProjectIgnore(projectPath) {
   const ig = ignore();
   ig.add(DEFAULT_IGNORES);
@@ -106631,7 +106771,7 @@ async function loadProjectIgnore(projectPath) {
   }
   return ig;
 }
-var import_ignore3, ignore, DEFAULT_EXTENSIONS, DEFAULT_IGNORES;
+var import_ignore3, ignore, DEFAULT_EXTENSIONS, DEFAULT_IGNORES, cachedPolicy;
 var init_ignore_patterns = __esm(() => {
   init_dist();
   init_capture_policy();
@@ -106923,9 +107063,9 @@ class IndexManager {
     try {
       const securityConfig = config.get("security");
       const allowedExtensions = securityConfig.allowedExtensions || DEFAULT_ALLOWED_EXTENSIONS;
-      const combinedPattern = `**/*{${allowedExtensions.join(",")}}`;
+      const patterns = buildExtensionGlob(allowedExtensions);
       const ig = await this.loadGitignore(projectPath);
-      const matches = await globAsync(combinedPattern, {
+      const matches = await globAsync(patterns, {
         cwd: projectPath,
         nodir: true,
         dot: false
@@ -111224,7 +111364,7 @@ async function _indexProjectInternalImpl(rlm, projectPath, projectId, options =
   ];
   try {
     const ig = await loadGitignoreImpl(projectPath);
-    const files = await globAsync2(`**/*{${allowedExtensions.join(",")}}`, {
+    const files = await globAsync2(buildExtensionGlob(allowedExtensions), {
       cwd: projectPath,
       absolute: true,
       nodir: true,
@@ -111676,6 +111816,9 @@ class MemoryRepositoryPg {
     if (filters.types && filters.types.length > 0) {
       conditions.push(import_prisma2.Prisma.sql`type = ANY(${filters.types}::text[])`);
     }
+    if (filters.includePersistent === false) {
+      conditions.push(import_prisma2.Prisma.sql`level <> ${MemoryLevel.PERSISTENT}`);
+    }
     const whereClause = import_prisma2.Prisma.sql`WHERE ${import_prisma2.Prisma.join(conditions, " AND ")}`;
     const rows = await this.prisma.$queryRaw`
       SELECT id, content, type, level,
@@ -111710,6 +111853,8 @@ class MemoryRepositoryPg {
       conditions.push(import_prisma2.Prisma.sql`importance >= ${filters.minImportance}`);
     if (filters?.types && filters.types.length > 0)
       conditions.push(import_prisma2.Prisma.sql`type = ANY(${filters.types}::text[])`);
+    if (filters?.includePersistent === false)
+      conditions.push(import_prisma2.Prisma.sql`level <> ${MemoryLevel.PERSISTENT}`);
     const whereClause = import_prisma2.Prisma.sql`WHERE ${import_prisma2.Prisma.join(conditions, " AND ")}
       AND NOT EXISTS (
         SELECT 1 FROM memory_edges me
@@ -115957,20 +116102,21 @@ class DiscoverStage {
       payload: { projectId: ctx.projectId, projectPath: ctx.projectPath },
       timestamp: Date.now()
     });
-    const ig = await this.loadIgnore(ctx.projectPath, opts.includeTests ?? false);
+    const includeTests = opts.includeTests ?? false;
+    const ig = await this.loadIgnore(ctx.projectPath, includeTests);
+    const policy = this.loadPolicy(includeTests);
     const allowedExts = config.get("security").allowedExtensions ?? DEFAULT_EXTENSIONS;
     let relPaths;
     if (opts.filesToProcess && opts.filesToProcess.length > 0) {
       relPaths = opts.filesToProcess;
     } else {
-      const pattern = `**/*{${allowedExts.join(",")}}`;
-      const found = await glob(pattern, {
+      const found = await glob(buildExtensionGlob(allowedExts), {
         cwd: ctx.projectPath,
         nodir: true,
         dot: false,
         absolute: false
       });
-      relPaths = found.map((p) => path11.isAbsolute(p) ? path11.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p));
+      relPaths = found.map((p) => path11.isAbsolute(p) ? path11.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
     }
     if (ctx.resumeCursor?.path) {
       const cursorPath = ctx.resumeCursor.path;
@@ -116056,6 +116202,15 @@ class DiscoverStage {
       throw new Error(`required_file_unreadable:${relativePath}:${err.message}`);
     }
   }
+  loadPolicy(includeTests) {
+    const policy = getActiveCapturePolicy();
+    if (!includeTests)
+      return policy;
+    return {
+      ...policy,
+      rules: policy.rules.filter((rule) => !(rule.disposition === "Drop" && TEST_IGNORE_PATTERNS.has(rule.pattern)))
+    };
+  }
   async loadIgnore(projectPath, includeTests) {
     if (!includeTests)
       return loadProjectIgnore(projectPath);
@@ -116081,6 +116236,7 @@ var init_discover = __esm(() => {
   init_dist();
   init_symbol_repository_factory();
   init_ignore_patterns();
+  init_capture_policy();
   import_ignore4 = __toESM(require_ignore(), 1);
   ignore2 = import_ignore4.default.default ?? import_ignore4.default;
   TEST_IGNORE_PATTERNS = new Set([
@@ -118910,19 +119066,22 @@ class StructuralResolverRegistry {
     return resolver;
   }
 }
+function declarationGroupKey(file3, qualifiedName) {
+  return `${file3}\x00${qualifiedName}`;
+}
 function buildStructuralResolverDefinitions(documents) {
   const groups = new Map;
   const exportedRoots = new Set;
   for (const document2 of documents)
     for (const symbol27 of document2.structure.symbols) {
-      const key = `${document2.file}\x00${symbol27.qualifiedName}\x00${symbol27.kind}`;
+      const key = declarationGroupKey(document2.file, symbol27.qualifiedName);
       groups.set(key, (groups.get(key) ?? 0) + 1);
       if (symbol27.exported && symbol27.qualifiedName === symbol27.name) {
         exportedRoots.add(`${document2.file}\x00${symbol27.qualifiedName.split(".")[0]}`);
       }
     }
   return Object.freeze(documents.flatMap((document2) => document2.structure.symbols.map((symbol27) => {
-    const key = `${document2.file}\x00${symbol27.qualifiedName}\x00${symbol27.kind}`;
+    const key = declarationGroupKey(document2.file, symbol27.qualifiedName);
     const visibleNested = document2.dialect === "java" ? symbol27.signatureMaterial.modifiers.includes("public") && (["class", "interface", "enum"].includes(symbol27.kind) || symbol27.signatureMaterial.modifiers.includes("static")) : !symbol27.signatureMaterial.modifiers.includes("private");
     const isExportMarker = symbol27.kind === "export";
     return Object.freeze({
@@ -123959,7 +124118,7 @@ class MemoryController {
       types: types6,
       minImportance = 0.3,
       limit = 10,
-      includePersistent: _includePersistent = true,
+      includePersistent = true,
       includeRelated = false
     } = input;
     logger.info("Searching memories", {
@@ -123977,7 +124136,8 @@ class MemoryController {
       projectId,
       agentId,
       minImportance,
-      types: types6
+      types: types6,
+      includePersistent
     });
     logger.info("FTS search completed", {
       foundResults: ftsRows.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massa-ai/tools-api",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "author": "luizgmassa",
   "description": "massa-ai REST API server - Semantic code search, memory, and context compression",
   "type": "module",
@@ -21,8 +21,8 @@
     "test": "bun scripts/run-tests-isolated.ts"
   },
   "dependencies": {
-    "@massa-ai/core": "^1.9.0",
-    "@massa-ai/shared": "^1.9.0",
+    "@massa-ai/core": "^1.9.1",
+    "@massa-ai/shared": "^1.9.1",
     "elysia": "^1.2.25",
     "@elysiajs/swagger": "^1.2.0",
     "@elysiajs/cors": "^1.2.0",