/** A file discovered by the filesystem walker, ready for analysis */
export interface DiscoveredFile {
    path: string;
    filename: string;
    content: string;
    mtime: number;
    size: number;
}
/** A signal detected by an analyzer — evidence of AI/LLM usage */
export interface DetectionSignal {
    type: 'dependency' | 'env_var' | 'code_usage' | 'agent_construction' | 'framework_config';
    /**
     * Evidence weight — determines whether something qualifies as an agent.
     * Minimum weight of 60 required on at least one signal to declare an agent.
     *
     * 100 — agent workspace config (models.json in .openclaw/agents/*, CLAUDE.md, etc.)
     *  80 — framework definition file (crew.yaml, agents.yaml)
     *  60 — agent construction in code (AgentExecutor, Crew(), @tool, AssistantAgent)
     *  20 — AI credentials present (.env with API key)
     *  15 — AI dependency declared (package.json, requirements.txt)
     *  10 — AI SDK import only
     */
    weight: number;
    confidence: 'high' | 'medium' | 'low';
    source: string;
    provider?: string;
    framework?: string;
    models?: string[];
    projectName?: string;
    detail: string;
}
/** An AI agent or LLM integration detected within a project */
export interface DetectedAgent {
    name: string;
    providers: string[];
    frameworks: string[];
    models: string[];
    language: 'typescript' | 'javascript' | 'python' | 'ruby' | 'go' | 'unknown';
    signals: DetectionSignal[];
    confidence: 'high' | 'medium' | 'low';
}
/** A project directory containing one or more detected agents */
export interface DetectedProject {
    path: string;
    name: string;
    agents: DetectedAgent[];
    signalCount: number;
    language: 'typescript' | 'javascript' | 'python' | 'ruby' | 'go' | 'unknown';
}
/** Full scan result returned by the engine */
export interface ScanResult {
    projects: DetectedProject[];
    totalAgents: number;
    totalSignals: number;
    scanDurationMs: number;
    filesAnalyzed: number;
    cacheHits: number;
}
/** Per-file cache entry — stores signals so unchanged files can be skipped */
export interface CacheEntry {
    mtime: number;
    signals: DetectionSignal[];
}
/** Persistent scan cache */
export interface ScanCache {
    version: number;
    entries: Record<string, CacheEntry>;
    lastScanAt?: number;
}
/** Options for the scan engine */
export interface ScanOptions {
    maxCodeFileSize?: number;
    maxTargetFileSize?: number;
    maxDepth?: number;
    maxFiles?: number;
    maxTotalBytes?: number;
}
/** An agent detected by known-platform fingerprinting */
export interface PlatformAgent {
    name: string;
    platform: string;
    confidence: 'confirmed' | 'likely';
    location: string;
    model?: string;
    spawnCapable?: boolean;
    /**
     * true = developer tool (IDE assistant, shell API key, local model server).
     * These are shown informational only and are NEVER sent to the registration API.
     * Only agents with transient !== true (i.e. false or absent) are registered.
     */
    transient?: boolean;
    /**
     * true = local model server (Ollama, LM Studio).
     * These are infrastructure that agents call — not agents themselves.
     * Displayed in a separate "Model Servers" section, excluded from agent counts.
     */
    modelServer?: boolean;
}
/** An agent detected via scheduled task (cron / Task Scheduler) */
export interface ScheduledAgent {
    name: string;
    schedule: string;
    command: string;
    platform: 'cron' | 'task-scheduler';
    confidence: 'confirmed' | 'likely';
    location: string;
}
/** Result of a single platform detector run */
export interface PlatformDetector {
    name: string;
    detect(homeDir: string, projectDirs?: string[]): PlatformAgent[];
}
/** An active LLM API connection detected via network inspection */
export interface NetworkAgent {
    provider: string;
    processId: number;
    processName: string;
    remoteHost: string;
}
export interface CoverageDisclaimer {
    agentCount: number;
    platformCount: number;
    text: string;
}
/** Full v2 scan result with platform + network + code layers */
export interface ScanResultV2 extends ScanResult {
    platformAgents: PlatformAgent[];
    scheduledAgents: ScheduledAgent[];
    networkAgents: NetworkAgent[];
    disclaimer: CoverageDisclaimer;
}
/** Agent registration payload for the backend API */
export interface AgentRegistration {
    name: string;
    framework: string;
    providers: string[];
    language: string;
    projectPath: string;
    projectName: string;
}
/** Backend registration response per agent */
export interface RegisteredAgent {
    agentId: string;
    name: string;
    status: 'registered' | 'existing';
    sdkSnippet?: string;
}
/** Bulk registration response */
export interface BulkRegistrationResult {
    registered: RegisteredAgent[];
    skipped: {
        name: string;
        reason: string;
    }[];
}
/** Result of detecting an agent's entry file */
export interface EntryFileResult {
    /** Relative path from project root to the entry file */
    entryFile: string;
    /** How the entry file was detected */
    detectionMethod: string;
    /** Project language */
    language: 'python' | 'typescript' | 'javascript';
    /** Absolute path to the project root */
    projectPath: string;
    /** Agent name (used for ARKNA_AGENT_NAME) */
    agentName: string;
}
/** Per-agent result from auto-connect */
export interface AgentConnectResult {
    agentName: string;
    status: 'connected' | 'skipped' | 'failed' | 'already_configured' | 'already_instrumented' | 'no_entry_file';
    entryFile?: string;
    reason?: string;
}
/** Aggregate result from autoConnectAgents() */
export interface AutoConnectResult {
    connected: number;
    skipped: number;
    failed: number;
    agents: AgentConnectResult[];
}
//# sourceMappingURL=types.d.ts.map