interface ProjectScan {
    root: string;
    name: string;
    type: 'monorepo' | 'single-package';
    languages: LanguageInfo[];
    framework: string | null;
    database: DatabaseInfo | null;
    testRunner: string | null;
    packages: PackageInfo[];
    existing: ExistingConfig;
}
interface LanguageInfo {
    name: string;
    extensions: string[];
    percentage: number;
    fileCount: number;
}
interface DatabaseInfo {
    orm: string;
    type: string;
    schemaPath: string | null;
}
interface PackageInfo {
    name: string;
    path: string;
    type: 'api' | 'web' | 'cli' | 'lib' | 'plugin' | 'database' | 'unknown';
    language: string;
    entryPoint: string | null;
    fileCount: number;
}
interface ExistingConfig {
    claudeMd: boolean;
    claudeMdPath: string | null;
    claudeignore: boolean;
    claudeignorePath: string | null;
    agentsJson: boolean;
    mcpServers: string[];
}
interface AgentDefinition {
    name: string;
    model: 'opus' | 'sonnet' | 'haiku';
    context: string[];
    task: string;
    layer: number;
    dependsOn: string[];
}
interface DispatchPattern {
    name: string;
    agents: string[];
    description: string;
}
interface AgentsConfig {
    version: string;
    project: string;
    agents: Record<string, AgentDefinition>;
    patterns: Record<string, string[]>;
}
interface HealthCheckResult {
    agent: string;
    check: string;
    status: 'pass' | 'fail' | 'warn';
    detail: string;
    fix?: string;
}

declare function detect(root: string): Promise<ProjectScan>;

declare function generateAgents(scan: ProjectScan): AgentsConfig;

declare function generateClaudeMd(root: string, scan: ProjectScan): {
    created: boolean;
    template: string;
};

declare function generateClaudeignore(root: string, scan: ProjectScan): {
    created: boolean;
    merged: boolean;
};

/** Supported AI coding tool platforms. */
type Platform = 'cursor' | 'windsurf' | 'codex';
/**
 * Generate a rules file for a single platform.
 * Merges non-destructively: if the target file exists and already contains
 * our marker section, the write is skipped. If the file exists without our
 * marker, our section is appended.
 */
declare function generatePlatformRules(root: string, scan: ProjectScan, platform: Platform): {
    created: boolean;
    path: string;
};
/**
 * Generate rules files for every supported platform in one call.
 * Returns an array of results, one per platform.
 */
declare function generateAllPlatforms(root: string, scan: ProjectScan): Array<{
    platform: Platform;
    created: boolean;
    path: string;
}>;

declare function createMemoryDb(root: string): void;

/**
 * Normalize a path to POSIX format (forward slashes).
 * Used for config paths stored in agents.json and displayed to users.
 * Filesystem operations should still use path.join().
 */
declare function toPosix(p: string): string;

type Tier = 1 | 2 | 3;
interface LanguageEntry {
    name: string;
    extensions: string[];
    tier: Tier;
    skipDirs: string[];
    entryPoints: string[];
    packageFiles: string[];
}
interface FrameworkDetector {
    name: string;
    language: string;
    detect: (root: string) => boolean;
    category: 'backend' | 'frontend' | 'fullstack' | 'mobile' | 'desktop';
}
interface TestRunnerDetector {
    name: string;
    language: string;
    detect: (root: string) => boolean;
    command: string;
}
interface OrmDetector {
    name: string;
    language: string;
    detect: (root: string) => string | null;
    schemaPaths: string[];
}

declare function getLanguageByExt(ext: string): LanguageEntry | undefined;
declare function getAllLanguages(): LanguageEntry[];
declare function getSkipDirs(): Set<string>;
declare function getEntryPoints(languageName: string): string[];
declare function getFrameworkDetectors(languageName?: string): FrameworkDetector[];
declare function getTestRunnerDetectors(languageName?: string): TestRunnerDetector[];
declare function getOrmDetectors(languageName?: string): OrmDetector[];

interface CollectedFile {
    relativePath: string;
    content: string;
    language: string | null;
    tokens: number;
}
interface CollectOptions {
    agentContextPaths?: string[];
    claudeignorePatterns?: string[];
}
declare function collectFiles(root: string, options: CollectOptions): CollectedFile[];

/**
 * Estimate token count from text.
 * Uses ~4 characters per token heuristic.
 * Accurate within ~10% for English text and code.
 */
declare function countTokens(text: string): number;
/**
 * Format a number with comma separators.
 * 15234 → "15,234"
 */
declare function formatTokenCount(n: number): string;

declare function formatXml(projectName: string, files: CollectedFile[], agentName?: string): string;

declare function formatMarkdown(projectName: string, files: CollectedFile[], agentName?: string): string;

interface PackOptions {
    dir: string;
    format: 'xml' | 'md';
    compress: boolean;
    agent?: string;
    noSecurity: boolean;
    affectedOnly?: string[];
    pruneTarget?: string;
}
interface PackResult {
    output: string;
    fileCount: number;
    totalTokens: number;
    rawTokens: number;
    skippedFiles: Array<{
        file: string;
        reason: string;
    }>;
    compressionRatio?: number;
}
declare function packProject(options: PackOptions): PackResult;

type RiskLevel = 'critical' | 'high' | 'medium' | 'low';

interface SecretMatch {
    pattern: string;
    category: string;
    risk: RiskLevel;
    line: number;
    file: string;
}
declare function scanForSecrets(content: string, filePath: string): SecretMatch[];
declare function isEnvFile(filePath: string): boolean;

/**
 * Compress code by extracting signatures and folding function bodies.
 * Tier A: regex-based, always available, ~60-70% token reduction.
 */
declare function compressCode(code: string, language: string): string;

interface CompressResult {
    code: string;
    method: 'tree-sitter' | 'regex' | 'none';
}
/**
 * Compress code using best available method.
 * Tier B (tree-sitter) if available, falls back to Tier A (regex).
 */
declare function compress(code: string, language: string): CompressResult;

interface ImportEdge {
    from: string;
    to: string;
}
interface BlastRadius {
    changedFile: string;
    directDependents: string[];
    transitiveDependents: string[];
    affectedTests: string[];
    riskScore: number;
    riskLevel: 'low' | 'medium' | 'high' | 'critical';
}
declare function buildImportGraph(root: string): Map<string, Set<string>>;
declare function getReverseDependencies(graph: Map<string, Set<string>>): Map<string, Set<string>>;
declare function computeBlastRadius(root: string, changedFile: string, graph?: Map<string, Set<string>>): BlastRadius;

interface IncrementalResult {
    added: string[];
    modified: string[];
    deleted: string[];
    unchanged: number;
    isFirstRun: boolean;
}
declare function detectChanges(root: string): IncrementalResult;
declare function hasChanges(root: string): boolean;

interface PackRun {
    date: string;
    project: string;
    projectPath: string;
    tokensRaw: number;
    tokensPacked: number;
    files: number;
    agent?: string;
    compressed: boolean;
    command: string;
    branch?: string;
    commit?: string;
    commitHash?: string;
    dirty?: number;
    duration?: number;
}
interface UsageStats {
    sessions: number;
    tokensSaved: number;
    tokensUsed: number;
}
declare function logPackRun(root: string, run: PackRun): void;
declare function readPackLogs(root: string): PackRun[];
declare function getStats(logs: PackRun[], days: number): UsageStats;

interface SearchResult {
    path: string;
    language: string | null;
    tokens: number;
    snippet: string;
    score: number;
    line: number;
}
interface SearchIndex {
    search(query: string, limit?: number): SearchResult[];
    rebuild(): {
        files: number;
        duration: number;
    };
    close(): void;
}
declare function createSearchIndex(root: string): SearchIndex;

interface GraphData {
    nodes: Array<{
        id: string;
        tokens: number;
        language: string | null;
        group: string;
    }>;
    edges: Array<{
        source: string;
        target: string;
    }>;
}
declare function buildGraphData(root: string): GraphData;
declare function generateVisualization(root: string, outputPath: string): {
    nodes: number;
    edges: number;
};

declare function startMcpServer(root: string): void;

export { type AgentDefinition, type AgentsConfig, type BlastRadius, type CollectOptions, type CollectedFile, type CompressResult, type DatabaseInfo, type DispatchPattern, type ExistingConfig, type FrameworkDetector, type GraphData, type HealthCheckResult, type ImportEdge, type IncrementalResult, type LanguageEntry, type LanguageInfo, type OrmDetector, type PackOptions, type PackResult, type PackRun, type PackageInfo, type Platform, type ProjectScan, type SearchIndex, type SearchResult, type SecretMatch, type TestRunnerDetector, type Tier, type UsageStats, buildGraphData, buildImportGraph, collectFiles, compress, compressCode, computeBlastRadius, countTokens, createMemoryDb, createSearchIndex, detect, detectChanges, formatMarkdown, formatTokenCount, formatXml, generateAgents, generateAllPlatforms, generateClaudeMd, generateClaudeignore, generatePlatformRules, generateVisualization, getAllLanguages, getEntryPoints, getFrameworkDetectors, getLanguageByExt, getOrmDetectors, getReverseDependencies, getSkipDirs, getStats, getTestRunnerDetectors, hasChanges, isEnvFile, logPackRun, packProject, readPackLogs, scanForSecrets, startMcpServer, toPosix };