@agentlighthouse/core 0.1.0-alpha.0

package/dist/reporters/shared.js

@@ -0,0 +1,26 @@
+export const severityOrder = ["critical", "high", "medium", "low", "info"];
+export function titleCase(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+export function topActionableFindings(findings, limit) {
+    return findings.filter((finding) => finding.severity !== "info").slice(0, limit);
+}
+export function findingLocation(finding) {
+    return finding.affectedFile ? ` (${finding.affectedFile})` : "";
+}
+export function severityRank(severity) {
+    return {
+        info: 0,
+        low: 1,
+        medium: 2,
+        high: 3,
+        critical: 4
+    }[severity];
+}
+export function confidenceRank(confidence) {
+    return {
+        low: 0,
+        medium: 1,
+        high: 2
+    }[confidence];
+}

package/dist/scanners/filesystem.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectSignals, ScanOptions, Scanner } from "../schemas/types.js";
+export declare class LocalFilesystemScanner implements Scanner {
+    readonly id = "local-filesystem";
+    scan(projectPath: string, options?: ScanOptions): Promise<ProjectSignals>;
+}
+//# sourceMappingURL=filesystem.d.ts.map

package/dist/scanners/filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../src/scanners/filesystem.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,cAAc,EACd,WAAW,EACX,OAAO,EACR,MAAM,qBAAqB,CAAC;AA0C7B,qBAAa,sBAAuB,YAAW,OAAO;IACpD,QAAQ,CAAC,EAAE,sBAAsB;IAE3B,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,cAAc,CAAC;CA+EpF"}

package/dist/scanners/filesystem.js

@@ -0,0 +1,231 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const defaultIgnores = [
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    ".next",
+    ".turbo",
+    ".vercel",
+    ".tmp",
+    "vendor",
+    ".DS_Store"
+];
+const textExtensions = new Set([
+    ".md",
+    ".mdx",
+    ".txt",
+    ".json",
+    ".yaml",
+    ".yml",
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".toml"
+]);
+const artifactPaths = [
+    "AGENTS.md",
+    "CLAUDE.md",
+    "llms.txt",
+    "README.md",
+    ".cursor/rules",
+    ".github/copilot-instructions.md",
+    ".agentlighthouseignore"
+];
+export class LocalFilesystemScanner {
+    id = "local-filesystem";
+    async scan(projectPath, options = {}) {
+        const rootPath = path.resolve(projectPath);
+        const maxFileSizeBytes = options.maxFileSizeBytes ?? 512_000;
+        const ignoreRules = await readIgnoreRules(rootPath, options.exclude ?? []);
+        const ignoredPaths = [];
+        const scannedFiles = await walk(rootPath, rootPath, ignoreRules, options.include ?? [], ignoredPaths);
+        const textByPath = {};
+        const artifacts = {};
+        let bytesRead = 0;
+        for (const relativePath of scannedFiles) {
+            const absolutePath = path.join(rootPath, relativePath);
+            const stat = await fs.stat(absolutePath);
+            if (stat.size <= maxFileSizeBytes && isTextFile(relativePath)) {
+                textByPath[relativePath] = await fs.readFile(absolutePath, "utf8");
+                bytesRead += stat.size;
+            }
+        }
+        for (const artifactPath of artifactPaths) {
+            const absolutePath = path.join(rootPath, artifactPath);
+            artifacts[artifactPath] = await artifactSignal(absolutePath, artifactPath, textByPath);
+        }
+        const docsMarkdownFiles = scannedFiles.filter((file) => file.startsWith("docs/") && [".md", ".mdx"].includes(path.extname(file)));
+        const openApiFiles = scannedFiles.filter(isOpenApiFile);
+        const mcpFiles = scannedFiles.filter((file) => /(^|\/)mcp\.json$/i.test(file) ||
+            /(^|\/)mcp-server\.[jt]sx?$/i.test(file) ||
+            /(^|\/)mcp-server\.example\.txt$/i.test(file));
+        const benchmarkFiles = scannedFiles.filter((file) => [
+            "agentlighthouse.tasks.yaml",
+            "agentlighthouse.tasks.yml",
+            "benchmarks/agent-tasks.yaml",
+            "benchmarks/agent-tasks.yml",
+            ".agentlighthouse/tasks.yaml",
+            ".agentlighthouse/tasks.yml"
+        ].includes(file));
+        const configFiles = scannedFiles.filter(isConfigFile);
+        const packageJson = parsePackageJson(textByPath["package.json"]);
+        const projectName = packageJson?.name ?? path.basename(rootPath);
+        return {
+            rootPath,
+            projectName,
+            scannedFiles,
+            artifacts,
+            docsMarkdownFiles,
+            openApiFiles,
+            mcpFiles: [...new Set([...mcpFiles, ...mcpPackageSignals(packageJson)])],
+            configFiles,
+            benchmarkFiles,
+            ignoredPaths: ignoredPaths.sort(),
+            warnings: [],
+            errors: [],
+            scanStats: {
+                filesScanned: scannedFiles.length,
+                textFilesRead: Object.keys(textByPath).length,
+                bytesRead,
+                docsMarkdownFileCount: docsMarkdownFiles.length,
+                openApiFileCount: openApiFiles.length,
+                benchmarkFileCount: benchmarkFiles.length
+            },
+            packageJson,
+            textByPath
+        };
+    }
+}
+async function artifactSignal(absolutePath, relativePath, textByPath) {
+    try {
+        const stat = await fs.stat(absolutePath);
+        return {
+            path: relativePath,
+            exists: true,
+            kind: stat.isDirectory() ? "directory" : "file",
+            sizeBytes: stat.size,
+            contentPreview: textByPath[relativePath]?.slice(0, 500)
+        };
+    }
+    catch {
+        return { path: relativePath, exists: false, kind: "missing" };
+    }
+}
+async function readIgnoreRules(rootPath, extraExcludes) {
+    const rules = [...defaultIgnores, ...extraExcludes];
+    for (const ignoreFile of [".gitignore", ".agentlighthouseignore"]) {
+        try {
+            const content = await fs.readFile(path.join(rootPath, ignoreFile), "utf8");
+            rules.push(...content
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => line && !line.startsWith("#")));
+        }
+        catch {
+            // Missing ignore files are expected in many target repos.
+        }
+    }
+    return rules;
+}
+async function walk(rootPath, currentPath, ignoreRules, includes, ignoredPaths) {
+    const entries = await fs.readdir(currentPath, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const absolutePath = path.join(currentPath, entry.name);
+        const relativePath = normalizePath(path.relative(rootPath, absolutePath));
+        if (shouldIgnore(relativePath, entry.name, ignoreRules)) {
+            if (ignoredPaths.length < 500) {
+                ignoredPaths.push(relativePath);
+            }
+            continue;
+        }
+        if (entry.isDirectory()) {
+            files.push(...(await walk(rootPath, absolutePath, ignoreRules, includes, ignoredPaths)));
+            continue;
+        }
+        if (entry.isFile() && matchesInclude(relativePath, includes)) {
+            files.push(relativePath);
+        }
+    }
+    return files.sort();
+}
+function normalizePath(filePath) {
+    return filePath.split(path.sep).join("/");
+}
+function shouldIgnore(relativePath, basename, rules) {
+    return rules.some((rawRule) => {
+        const rule = rawRule.replace(/^\//, "").replace(/\/$/, "");
+        if (!rule || rule.startsWith("!")) {
+            return false;
+        }
+        if (rule.includes("*")) {
+            const pattern = new RegExp(`^${escapeRegex(rule).replaceAll("\\*", ".*")}$`);
+            return pattern.test(relativePath) || pattern.test(basename);
+        }
+        return relativePath === rule || relativePath.startsWith(`${rule}/`) || basename === rule;
+    });
+}
+function matchesInclude(relativePath, includes) {
+    if (includes.length === 0) {
+        return true;
+    }
+    return includes.some((include) => relativePath.includes(include.replaceAll("*", "")));
+}
+function escapeRegex(value) {
+    return value.replace(/[|\\{}()[\]^$+?.*]/g, "\\$&");
+}
+function isTextFile(file) {
+    return (textExtensions.has(path.extname(file)) || ["AGENTS.md", "CLAUDE.md", "llms.txt"].includes(file));
+}
+function isOpenApiFile(file) {
+    const lower = file.toLowerCase();
+    return (lower.endsWith("openapi.yaml") ||
+        lower.endsWith("openapi.yml") ||
+        lower.endsWith("openapi.json") ||
+        lower.endsWith("swagger.yaml") ||
+        lower.endsWith("swagger.yml") ||
+        lower.endsWith("swagger.json"));
+}
+function isConfigFile(file) {
+    return [
+        "package.json",
+        "tsconfig.json",
+        "tsconfig.base.json",
+        "eslint.config.mjs",
+        "next.config.ts",
+        "vite.config.ts",
+        "vitest.config.ts",
+        "agentlighthouse.config.json"
+    ].includes(file);
+}
+function parsePackageJson(content) {
+    if (!content) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(content);
+        return {
+            path: "package.json",
+            name: parsed.name,
+            packageManager: parsed.packageManager,
+            scripts: parsed.scripts ?? {},
+            dependencies: Object.keys(parsed.dependencies ?? {}),
+            devDependencies: Object.keys(parsed.devDependencies ?? {})
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function mcpPackageSignals(packageJson) {
+    if (!packageJson) {
+        return [];
+    }
+    return [...packageJson.dependencies, ...packageJson.devDependencies].filter((dependency) => dependency.toLowerCase().includes("mcp"));
+}