pi-harness-runtime 0.10.12 → 0.10.13

package/packages/privilege-broker/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"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"}

package/packages/privilege-broker/dist/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Privilege Broker — Types
+ * RFC-0101 §7-§8
+ *
+ * Duplicates CapabilityName from @pi/autonomous-runtime here to avoid
+ * circular import issues in the workspace. Once the workspace is built,
+ * this can be replaced with:
+ *   import type { CapabilityName } from "@pi/autonomous-runtime";
+ */
+/** A named capability that the privilege broker may grant. */
+export type CapabilityName = "files.read" | "files.write" | "files.exec" | "git.commit" | "git.push" | "gh.api" | "npm.publish" | "run_command" | "sudo";
+/** Policy for one capability. */
+export interface PrivilegeEntry {
+    capability: CapabilityName;
+    /** Human-readable description shown in approval prompts. */
+    description: string;
+    /** Per-actor policy. Default deny if no match. */
+    actors: Record<string, {
+        /** "allow", "deny", or "ask" (requires human approval). */
+        default: "allow" | "deny" | "ask";
+        /** Optional: cron expression for time-of-day restriction. */
+        time_window?: string;
+        /** Optional: condition expression evaluated at runtime. */
+        condition?: string;
+        /** Max exec-time in ms. 0 = no limit. */
+        timeout_ms?: number;
+        /** Environment variable whitelist (exact keys). */
+        env_whitelist?: string[];
+        /** Optional: working directory constraint. */
+        allowed_cwd?: string;
+    }>;
+    /** Approval class id — determines how to prompt human. */
+    approval_class: string;
+}
+/** Loaded registry of all known capabilities. */
+export interface PrivilegeRegistry {
+    version: number;
+    capabilities: PrivilegeEntry[];
+}
+/** Result of a broker.check() call. */
+export interface CapabilityGrant {
+    granted: boolean;
+    reason: string;
+    /** Filled if granted = true. */
+    exec_options?: {
+        timeout_ms?: number;
+        env_whitelist?: string[];
+        allowed_cwd?: string;
+    };
+}
+/** Log entry for audit trail. */
+export type AuditOutcome = "granted" | "denied" | "auto_denied" | "auto_approved" | "error";
+export interface AuditEntry {
+    timestamp: string;
+    workerId?: string;
+    taskId?: string;
+    actor: string;
+    capability: CapabilityName;
+    reason: string;
+    outcome: AuditOutcome;
+    success?: boolean;
+    error?: string;
+}
+/** Audit logger interface. */
+export interface AuditLogger {
+    log(entry: AuditEntry): void;
+}
+/** Approval class — determines how to prompt the human. */
+export interface ApprovalClass {
+    id: string;
+    /**
+     * Prompt the human for approval.
+     * Returns "granted" or "denied".
+     */
+    prompt(capability: CapabilityName, actor: string, reason: string): Promise<"granted" | "denied">;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/privilege-broker/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,8DAA8D;AAC9D,MAAM,MAAM,cAAc,GACvB,YAAY,GACZ,aAAa,GACb,YAAY,GACZ,YAAY,GACZ,UAAU,GACV,QAAQ,GACR,aAAa,GACb,aAAa,GACb,MAAM,CAAC;AAEV,iCAAiC;AACjC,MAAM,WAAW,cAAc;IAC9B,UAAU,EAAE,cAAc,CAAC;IAC3B,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,MAAM,EAAE,MAAM,CACb,MAAM,EACN;QACC,2DAA2D;QAC3D,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;QAClC,6DAA6D;QAC7D,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,2DAA2D;QAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,yCAAyC;QACzC,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,mDAAmD;QACnD,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;QACzB,8CAA8C;QAC9C,WAAW,CAAC,EAAE,MAAM,CAAC;KACrB,CACD,CAAC;IACF,0DAA0D;IAC1D,cAAc,EAAE,MAAM,CAAC;CACvB;AAED,iDAAiD;AACjD,MAAM,WAAW,iBAAiB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,cAAc,EAAE,CAAC;CAC/B;AAED,uCAAuC;AACvC,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,YAAY,CAAC,EAAE;QACd,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;QACzB,WAAW,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACF;AAED,iCAAiC;AACjC,MAAM,MAAM,YAAY,GACrB,SAAS,GACT,QAAQ,GACR,aAAa,GACb,eAAe,GACf,OAAO,CAAC;AAEX,MAAM,WAAW,UAAU;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,cAAc,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,8BAA8B;AAC9B,MAAM,WAAW,WAAW;IAC3B,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;CAC7B;AAED,2DAA2D;AAC3D,MAAM,WAAW,aAAa;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX;;;OAGG;IACH,MAAM,CACL,UAAU,EAAE,cAAc,EAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACZ,OAAO,CAAC,SAAS,GAAG,QAAQ,CAAC,CAAC;CACjC"}

package/packages/privilege-broker/dist/types.js

@@ -0,0 +1,11 @@
+/**
+ * Privilege Broker — Types
+ * RFC-0101 §7-§8
+ *
+ * Duplicates CapabilityName from @pi/autonomous-runtime here to avoid
+ * circular import issues in the workspace. Once the workspace is built,
+ * this can be replaced with:
+ *   import type { CapabilityName } from "@pi/autonomous-runtime";
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/packages/privilege-broker/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/packages/project-analyzer/dist/analyzer.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Project Analyzer
+ *
+ * Main analyzer implementation that orchestrates project analysis.
+ */
+import type { AnalyzeRequest, AnalyzeResult, DetectedLanguage, FrameworkAnalyzerPlugin, ReadonlyFileSystem, TestCapability } from "./types.js";
+import { AnalysisCache } from "./cache.js";
+/**
+ * Default framework analyzer plugins.
+ * These are used when no custom plugins are provided.
+ */
+export declare const DEFAULT_PLUGINS: FrameworkAnalyzerPlugin[];
+/**
+ * Count language coverage from scanned files.
+ */
+export declare function detectLanguages(files: {
+    relativePath: string;
+    size: number;
+}[]): DetectedLanguage[];
+/**
+ * Detect test capabilities from project files.
+ */
+export declare function detectTestCapabilities(fs: ReadonlyFileSystem, framework: string): Promise<TestCapability[]>;
+/**
+ * Project analyzer implementation.
+ */
+export declare class ProjectAnalyzer {
+    private cache;
+    private plugins;
+    private defaultDetector;
+    constructor(options?: {
+        cache?: AnalysisCache;
+        plugins?: FrameworkAnalyzerPlugin[];
+    });
+    /**
+     * Get git revision for a repository.
+     */
+    private getGitRevision;
+    /**
+     * Parse JSON file safely.
+     */
+    private parseJsonFile;
+    /**
+     * Run framework detection.
+     */
+    private detectFrameworks;
+    /**
+     * Discover rules from project.
+     */
+    private discoverRules;
+    /**
+     * Discover commands from project.
+     */
+    private discoverCommands;
+    /**
+     * Analyze a project.
+     */
+    analyze(request: AnalyzeRequest): Promise<AnalyzeResult>;
+}
+/**
+ * Create a project analyzer with default configuration.
+ */
+export declare function createProjectAnalyzer(options?: {
+    cache?: AnalysisCache;
+    plugins?: FrameworkAnalyzerPlugin[];
+}): ProjectAnalyzer;
+//# sourceMappingURL=analyzer.d.ts.map

package/packages/project-analyzer/dist/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAEX,cAAc,EACd,aAAa,EAGb,gBAAgB,EAChB,uBAAuB,EACvB,kBAAkB,EAClB,cAAc,EAGd,MAAM,YAAY,CAAC;AAGpB,OAAO,EACN,aAAa,EAIb,MAAM,YAAY,CAAC;AAkBpB;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,uBAAuB,EAAO,CAAC;AA0B7D;;GAEG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,GAC7C,gBAAgB,EAAE,CA8BpB;AAID;;GAEG;AACH,wBAAsB,sBAAsB,CAC3C,EAAE,EAAE,kBAAkB,EACtB,SAAS,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,EAAE,CAAC,CAgF3B;AAID;;GAEG;AACH,qBAAa,eAAe;IAC3B,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,eAAe,CAA2B;IAElD,YACC,OAAO,GAAE;QACR,KAAK,CAAC,EAAE,aAAa,CAAC;QACtB,OAAO,CAAC,EAAE,uBAAuB,EAAE,CAAC;KAC/B,EAKN;IAED;;OAEG;YACW,cAAc;IAa5B;;OAEG;YACW,aAAa;IAS3B;;OAEG;YACW,gBAAgB;IAqF9B;;OAEG;YACW,aAAa;IAc3B;;OAEG;YACW,gBAAgB;IA+C9B;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAmQ7D;CACD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE;IAC/C,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,OAAO,CAAC,EAAE,uBAAuB,EAAE,CAAC;CACpC,GAAG,eAAe,CAElB"}

package/packages/project-analyzer/dist/analyzer.js

@@ -0,0 +1,512 @@
+/**
+ * Project Analyzer
+ *
+ * Main analyzer implementation that orchestrates project analysis.
+ */
+import { readFile } from "node:fs/promises";
+import { join, basename, dirname } from "node:path";
+import { execSync } from "node:child_process";
+import { FileSystemWalker, createReadonlyFileSystem } from "./walker.js";
+import { AnalysisCache, hashRuleFiles, hashManifestFiles, hashFrameworkConfigFiles, } from "./cache.js";
+import { discoverRuleFiles, mergeRules, extractCommandsFromRules, extractMetadataFromRules, } from "./rule-discovery.js";
+import { parsePackageJsonScripts, categorizeCommands, detectPackageManager, parsePythonCommands, parseComposerScripts, } from "./command-discovery.js";
+import { GenericFrameworkDetector } from "./signals.js";
+// --- Default Plugins ----------------------------------------------------
+/**
+ * Default framework analyzer plugins.
+ * These are used when no custom plugins are provided.
+ */
+export const DEFAULT_PLUGINS = [];
+// --- Language Detection ------------------------------------------------
+/**
+ * Language file extensions mapping.
+ */
+const LANGUAGE_EXTENSIONS = {
+    TypeScript: [".ts", ".tsx"],
+    JavaScript: [".js", ".jsx", ".mjs", ".cjs"],
+    Python: [".py"],
+    Ruby: [".rb"],
+    PHP: [".php"],
+    Go: [".go"],
+    Rust: [".rs"],
+    Java: [".java", ".kt", ".kts"],
+    "C#": [".cs"],
+    "C++": [".cpp", ".cc", ".cxx", ".h", ".hpp"],
+    C: [".c"],
+    Swift: [".swift"],
+    HTML: [".html", ".htm"],
+    CSS: [".css", ".scss", ".sass", ".less"],
+    SQL: [".sql"],
+    Markdown: [".md", ".mdx"],
+};
+/**
+ * Count language coverage from scanned files.
+ */
+export function detectLanguages(files) {
+    const counts = {};
+    let totalBytes = 0;
+    for (const file of files) {
+        for (const [lang, extensions] of Object.entries(LANGUAGE_EXTENSIONS)) {
+            for (const langExt of extensions) {
+                if (file.relativePath.endsWith(langExt)) {
+                    counts[lang] = counts[lang] || { files: 0, bytes: 0 };
+                    counts[lang].files++;
+                    counts[lang].bytes += file.size;
+                    totalBytes += file.size;
+                    break;
+                }
+            }
+        }
+    }
+    const languages = [];
+    for (const [lang, data] of Object.entries(counts)) {
+        languages.push({
+            name: lang,
+            coverage: totalBytes > 0 ? data.bytes / totalBytes : 0,
+        });
+    }
+    // Sort by coverage descending
+    languages.sort((a, b) => b.coverage - a.coverage);
+    return languages;
+}
+// --- Test Capability Detection -----------------------------------------
+/**
+ * Detect test capabilities from project files.
+ */
+export async function detectTestCapabilities(fs, framework) {
+    const capabilities = [];
+    // Common test runner patterns
+    const testRunners = [
+        {
+            runner: "vitest",
+            configFiles: [
+                "vitest.config.ts",
+                "vitest.config.js",
+                "vitest.config.mts",
+            ],
+        },
+        {
+            runner: "jest",
+            configFiles: [
+                "jest.config.js",
+                "jest.config.ts",
+                "jest.config.json",
+                "package.json",
+            ],
+        },
+        {
+            runner: "playwright",
+            configFiles: ["playwright.config.ts", "playwright.config.js"],
+        },
+        {
+            runner: "cypress",
+            configFiles: ["cypress.config.ts", "cypress.config.js"],
+        },
+        { runner: "bun_test", configFiles: [] }, // Detected via bun.lockb and test scripts
+        {
+            runner: "pytest",
+            configFiles: ["pytest.ini", "setup.cfg", "pyproject.toml"],
+        },
+        { runner: "phpunit", configFiles: ["phpunit.xml", "phpunit.xml.dist"] },
+        { runner: "bench_test", configFiles: ["apps.txt", "sites/"] },
+    ];
+    for (const { runner, configFiles } of testRunners) {
+        if (configFiles.length === 0) {
+            // No config file needed
+            const hasPackage = await fs.exists("package.json");
+            const hasBunLock = await fs.exists("bun.lockb");
+            if (runner === "bun_test" && (hasPackage || hasBunLock)) {
+                capabilities.push({
+                    runner,
+                    available: true,
+                    pattern: "*.test.ts",
+                });
+            }
+            continue;
+        }
+        for (const configFile of configFiles) {
+            if (await fs.exists(configFile)) {
+                capabilities.push({
+                    runner,
+                    configPath: configFile,
+                    available: true,
+                });
+                break;
+            }
+        }
+    }
+    // Check for bench_test in Frappe
+    if (framework === "frappe") {
+        const hasAppsTxt = await fs.exists("apps.txt");
+        const hasSites = await fs.exists("sites");
+        if (hasAppsTxt || hasSites) {
+            capabilities.push({
+                runner: "bench_test",
+                available: true,
+            });
+        }
+    }
+    return capabilities;
+}
+// --- Main Analyzer -----------------------------------------------------
+/**
+ * Project analyzer implementation.
+ */
+export class ProjectAnalyzer {
+    cache;
+    plugins;
+    defaultDetector;
+    constructor(options = {}) {
+        this.cache = options.cache || new AnalysisCache();
+        this.plugins = options.plugins || DEFAULT_PLUGINS;
+        this.defaultDetector = new GenericFrameworkDetector();
+    }
+    /**
+     * Get git revision for a repository.
+     */
+    async getGitRevision(rootPath) {
+        try {
+            const revision = execSync("git rev-parse HEAD", {
+                cwd: rootPath,
+                encoding: "utf-8",
+                timeout: 5000,
+            }).trim();
+            return revision;
+        }
+        catch {
+            return "unknown";
+        }
+    }
+    /**
+     * Parse JSON file safely.
+     */
+    async parseJsonFile(path) {
+        try {
+            const content = await readFile(path, "utf-8");
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Run framework detection.
+     */
+    async detectFrameworks(fs) {
+        const warnings = [];
+        const detectedFrameworks = [];
+        // Try custom plugins first
+        const pluginResults = [];
+        for (const plugin of this.plugins) {
+            try {
+                const result = await plugin.detect(fs);
+                if (result) {
+                    pluginResults.push({
+                        framework: {
+                            category: result.category,
+                            name: result.category
+                                .replace(/_/g, " ")
+                                .replace(/\b\w/g, (c) => c.toUpperCase()),
+                            version: result.version,
+                            confidence: result.confidence,
+                            signals: result.signals,
+                            primary: detectedFrameworks.length === 0,
+                        },
+                        pluginId: plugin.id,
+                    });
+                }
+            }
+            catch {
+                // Plugin detection failed, continue
+            }
+        }
+        // If no plugins matched, use generic detector
+        if (pluginResults.length === 0) {
+            const genericResults = await this.defaultDetector.detect(fs);
+            for (const result of genericResults) {
+                pluginResults.push({
+                    framework: {
+                        category: result.category,
+                        name: result.category
+                            .replace(/_/g, " ")
+                            .replace(/\b\w/g, (c) => c.toUpperCase()),
+                        version: result.version,
+                        confidence: result.confidence,
+                        signals: result.signals,
+                        primary: detectedFrameworks.length === 0,
+                    },
+                    pluginId: "generic",
+                });
+            }
+        }
+        // Sort by confidence and add warnings for conflicts
+        pluginResults.sort((a, b) => b.framework.confidence - a.framework.confidence);
+        for (const result of pluginResults) {
+            // Check for conflicting frameworks
+            const existingPrimary = detectedFrameworks.find((f) => f.primary);
+            if (existingPrimary && result.framework.confidence > 0.5) {
+                warnings.push({
+                    code: "CONFLICTING_FRAMEWORKS",
+                    message: `Multiple frameworks detected: ${existingPrimary.name} and ${result.framework.name}`,
+                });
+            }
+            detectedFrameworks.push(result.framework);
+        }
+        if (detectedFrameworks.length === 0) {
+            warnings.push({
+                code: "NO_FRAMEWORK_DETECTED",
+                message: "No specific framework detected, using generic profile",
+            });
+        }
+        return { frameworks: detectedFrameworks, warnings };
+    }
+    /**
+     * Discover rules from project.
+     */
+    async discoverRules(rootPath, fs) {
+        const ruleFiles = await discoverRuleFiles(rootPath, fs);
+        const rules = mergeRules(ruleFiles);
+        const metadata = extractMetadataFromRules(rules);
+        return { rules, metadata };
+    }
+    /**
+     * Discover commands from project.
+     */
+    async discoverCommands(rootPath, _fs) {
+        const allCommands = [];
+        // Parse package.json if exists
+        const packageJson = await this.parseJsonFile(join(rootPath, "package.json"));
+        if (packageJson) {
+            allCommands.push(...parsePackageJsonScripts(packageJson));
+        }
+        // Parse composer.json if exists
+        const composerJson = await this.parseJsonFile(join(rootPath, "composer.json"));
+        if (composerJson) {
+            allCommands.push(...parseComposerScripts(composerJson));
+        }
+        // Parse pyproject.toml if exists
+        const pyprojectToml = await this.parseJsonFile(join(rootPath, "pyproject.toml"));
+        if (pyprojectToml) {
+            allCommands.push(...parsePythonCommands(JSON.stringify(pyprojectToml)));
+        }
+        // Categorize commands
+        const commands = categorizeCommands(allCommands);
+        // Extract permitted/prohibited from rules
+        // This is handled separately by rule discovery
+        return {
+            commands,
+            permitted: [],
+            prohibited: [],
+        };
+    }
+    /**
+     * Analyze a project.
+     */
+    async analyze(request) {
+        const startTime = Date.now();
+        try {
+            const rootPath = request.repositoryRoot;
+            // Get git revision
+            const revision = request.revision || (await this.getGitRevision(rootPath));
+            // Create filesystem walker
+            const walker = new FileSystemWalker(rootPath, request.config);
+            const fs = createReadonlyFileSystem(walker);
+            // Scan filesystem
+            const scanResult = await walker.scan();
+            // Try cache first
+            const ruleFiles = await discoverRuleFiles(rootPath, fs);
+            const ruleHash = await hashRuleFiles(ruleFiles.map((f) => ({ path: f.path, content: f.content })));
+            const manifestFiles = scanResult.files
+                .filter((f) => ["package.json", "pyproject.toml", "composer.json"].includes(basename(f.path)))
+                .map((f) => ({
+                path: f.path,
+                content: walker.readFileSafe(f.path),
+            }));
+            const manifestContents = await Promise.all(manifestFiles.map((f) => f.content));
+            const manifestHash = await hashManifestFiles(manifestFiles.map((f, i) => ({
+                path: f.path,
+                content: manifestContents[i] || "",
+            })));
+            const frameworkConfigFiles = scanResult.files
+                .filter((f) => f.relativePath.includes("config") ||
+                [
+                    "next.config.js",
+                    "vite.config.ts",
+                    "tsconfig.json",
+                    "webpack.config.js",
+                ].some((c) => f.relativePath.endsWith(c)))
+                .map((f) => ({
+                path: f.path,
+                content: walker.readFileSafe(f.path),
+            }));
+            const frameworkConfigContents = await Promise.all(frameworkConfigFiles.map((f) => f.content));
+            const configHash = await hashFrameworkConfigFiles(frameworkConfigFiles.map((f, i) => ({
+                path: f.path,
+                content: frameworkConfigContents[i] || "",
+            })));
+            const cacheKey = this.cache.generateKey(rootPath, revision, configHash);
+            const cachedProfile = await this.cache.get(cacheKey);
+            if (cachedProfile) {
+                return {
+                    success: true,
+                    profile: cachedProfile,
+                    durationMs: Date.now() - startTime,
+                };
+            }
+            // Detect frameworks
+            const { frameworks, warnings: frameworkWarnings } = await this.detectFrameworks(fs);
+            const primaryFramework = frameworks.find((f) => f.primary);
+            // Detect languages
+            const languages = detectLanguages(scanResult.files);
+            // Detect package managers
+            const packageManagerFiles = scanResult.files
+                .filter((f) => {
+                const name = basename(f.path);
+                return [
+                    "package.json",
+                    "yarn.lock",
+                    "pnpm-lock.yaml",
+                    "bun.lockb",
+                    "requirements.txt",
+                    "Pipfile",
+                    "poetry.lock",
+                    "composer.json",
+                ].includes(name);
+            })
+                .map((f) => f.relativePath);
+            const primaryPackageManager = detectPackageManager(packageManagerFiles);
+            // Discover rules
+            const { rules } = await this.discoverRules(rootPath, fs);
+            // Discover commands
+            const { commands } = await this.discoverCommands(rootPath, fs);
+            // Extract permitted/prohibited commands from rules (for future use)
+            extractCommandsFromRules(rules);
+            // Detect test capabilities
+            const testCapabilities = await detectTestCapabilities(fs, primaryFramework?.category || "unknown");
+            // Detect applications (monorepo support)
+            const applications = [];
+            if (request.config?.detectMonorepo !== false) {
+                // Look for sub-applications
+                const subdirs = scanResult.files
+                    .filter((f) => {
+                    const parts = f.relativePath.split("/");
+                    return (parts.length >= 2 &&
+                        parts[parts.length - 1] === "package.json" &&
+                        !f.relativePath.startsWith("node_modules"));
+                })
+                    .map((f) => dirname(f.relativePath));
+                for (const subdir of subdirs) {
+                    const packageJson = await this.parseJsonFile(join(rootPath, subdir, "package.json"));
+                    if (packageJson && packageJson.name) {
+                        applications.push({
+                            id: String(packageJson.name),
+                            root: join(rootPath, subdir),
+                            framework: "unknown",
+                            packageManager: primaryPackageManager || undefined,
+                            testCommands: [],
+                            buildCommands: [],
+                            entryPoints: [],
+                            relativePath: subdir,
+                        });
+                    }
+                }
+            }
+            // Build sensitive and generated paths
+            const sensitivePaths = scanResult.files
+                .filter((f) => f.sensitive)
+                .map((f) => f.relativePath);
+            const generatedPaths = scanResult.files
+                .filter((f) => f.generated)
+                .map((f) => f.relativePath);
+            // Calculate confidence
+            const avgFrameworkConfidence = frameworks.length > 0
+                ? frameworks.reduce((sum, f) => sum + f.confidence, 0) /
+                    frameworks.length
+                : 0;
+            // Build warnings
+            const warnings = [...frameworkWarnings];
+            if (languages.length === 0) {
+                warnings.push({
+                    code: "UNKNOWN_LANGUAGE",
+                    message: "No programming languages detected",
+                });
+            }
+            if (testCapabilities.length === 0) {
+                warnings.push({
+                    code: "NO_TEST_CONFIG",
+                    message: "No test configuration detected",
+                });
+            }
+            if (packageManagerFiles.length > 1) {
+                warnings.push({
+                    code: "MULTIPLE_PACKAGE_MANAGERS",
+                    message: `Multiple package managers detected: ${packageManagerFiles.join(", ")}`,
+                    affected: packageManagerFiles,
+                });
+            }
+            // Build profile
+            const profile = {
+                repositoryRoot: rootPath,
+                repositoryName: basename(rootPath),
+                revision,
+                frameworks,
+                languages,
+                packageManagers: primaryPackageManager
+                    ? [
+                        {
+                            type: primaryPackageManager,
+                            configPath: packageManagerFiles.find((f) => f.includes(primaryPackageManager)) || "",
+                            primary: true,
+                        },
+                    ]
+                    : [],
+                applications,
+                commands,
+                rules,
+                sensitivePaths,
+                generatedPaths,
+                testCapabilities,
+                confidence: avgFrameworkConfidence,
+                warnings,
+                analyzedAt: new Date().toISOString(),
+            };
+            // Cache result
+            await this.cache.set(cacheKey, profile, {
+                ruleHash,
+                manifestHash,
+                configHash,
+            });
+            return {
+                success: true,
+                profile,
+                durationMs: Date.now() - startTime,
+            };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            let errorCode = "UNKNOWN_ERROR";
+            if (error.includes("ENOENT")) {
+                errorCode = "REPOSITORY_NOT_FOUND";
+            }
+            else if (error.includes("not a directory")) {
+                errorCode = "NOT_A_DIRECTORY";
+            }
+            else if (error.includes("escape")) {
+                errorCode = "SYMLINK_ESCAPE";
+            }
+            return {
+                success: false,
+                error,
+                errorCode,
+                durationMs: Date.now() - startTime,
+            };
+        }
+    }
+}
+/**
+ * Create a project analyzer with default configuration.
+ */
+export function createProjectAnalyzer(options) {
+    return new ProjectAnalyzer(options);
+}
+//# sourceMappingURL=analyzer.js.map