aiwg/dist/src/extensions/capability-index.d.ts

Deployment tool and support utility for AI context. Copies agents, skills, commands, rules, and behaviors into the paths each AI platform reads (Claude Code, Codex, Copilot, Cursor, Warp, OpenClaw, and 6 more) so one source of truth works across 10 platfo

/**
 * CapabilityIndex - Capability-based extension discovery system
 *
 * @implements @.aiwg/requirements/use-cases/UC-004-extension-system.md
 * @architecture @.aiwg/architecture/software-architecture-doc.md
 * @tests @test/unit/extensions/capability-index.test.ts
 */
import type { Extension } from './types.js';
/**
 * Query structure for capability-based extension search
 */
export interface CapabilityQuery {
    /** Find extensions with ALL these capabilities */
    all?: string[];
    /** Find extensions with ANY of these capabilities */
    any?: string[];
    /** Exclude extensions with these capabilities */
    not?: string[];
    /** Filter by extension type */
    type?: string;
}
/**
 * CapabilityIndex enables finding extensions by what they can do.
 *
 * Maintains bidirectional mappings:
 * - capability → extension IDs (for queries)
 * - extension ID → capabilities (for updates)
 *
 * @example
 * ```typescript
 * const index = new CapabilityIndex();
 * index.index(myExtension);
 *
 * // Find extensions that can format markdown
 * const formatters = index.getByCapability('format:markdown');
 *
 * // Find extensions that can format OR lint
 * const tools = index.query({ any: ['format:markdown', 'lint:markdown'] });
 *
 * // Find formatters that are NOT linters
 * const pureFormatters = index.query({
 *   all: ['format:markdown'],
 *   not: ['lint:markdown']
 * });
 * ```
 */
export declare class CapabilityIndex {
    /** Map of capability → extension IDs */
    private byCapability;
    /** Map of extension ID → capabilities */
    private byExtension;
    /** Map of extension ID → extension type */
    private extensionTypes;
    /**
     * Index an extension's capabilities for fast lookup.
     *
     * @param extension - Extension to index
     *
     * @example
     * ```typescript
     * index.index({
     *   id: 'markdown-formatter',
     *   type: 'tool',
     *   capabilities: ['format:markdown', 'format:commonmark']
     * });
     * ```
     */
    index(extension: Extension): void;
    /**
     * Remove an extension from the index.
     *
     * @param extensionId - ID of extension to remove
     *
     * @example
     * ```typescript
     * index.remove('markdown-formatter');
     * ```
     */
    remove(extensionId: string): void;
    /**
     * Query extensions by capabilities.
     *
     * Query logic:
     * 1. Start with all extensions if no `all` or `any` specified
     * 2. Filter to extensions with ALL capabilities in `all` array
     * 3. Filter to extensions with ANY capability in `any` array
     * 4. Exclude extensions with capabilities in `not` array
     * 5. Optionally filter by extension type
     *
     * @param query - Capability query
     * @returns Array of matching extension IDs
     *
     * @example
     * ```typescript
     * // Extensions that can do BOTH formatting and validation
     * index.query({ all: ['format:markdown', 'validate:markdown'] });
     *
     * // Extensions that can do EITHER formatting or linting
     * index.query({ any: ['format:markdown', 'lint:markdown'] });
     *
     * // Formatters that are NOT linters
     * index.query({
     *   all: ['format:markdown'],
     *   not: ['lint:markdown']
     * });
     *
     * // Only tool-type extensions with formatting capability
     * index.query({
     *   all: ['format:markdown'],
     *   type: 'tool'
     * });
     * ```
     */
    query(query: CapabilityQuery): string[];
    /**
     * Get all capabilities in the index.
     *
     * @returns Sorted array of capability strings
     *
     * @example
     * ```typescript
     * const capabilities = index.getAllCapabilities();
     * // ['format:markdown', 'lint:markdown', 'validate:markdown']
     * ```
     */
    getAllCapabilities(): string[];
    /**
     * Get all extensions with a specific capability.
     *
     * @param capability - Capability to search for
     * @returns Sorted array of extension IDs
     *
     * @example
     * ```typescript
     * const formatters = index.getByCapability('format:markdown');
     * // ['markdown-formatter', 'prettier-markdown']
     * ```
     */
    getByCapability(capability: string): string[];
    /**
     * Check if a capability exists in the index.
     *
     * @param capability - Capability to check
     * @returns True if at least one extension has this capability
     *
     * @example
     * ```typescript
     * if (index.hasCapability('format:markdown')) {
     *   console.log('Markdown formatting available');
     * }
     * ```
     */
    hasCapability(capability: string): boolean;
    /**
     * Get the number of unique capabilities in the index.
     *
     * @example
     * ```typescript
     * console.log(`Indexed ${index.capabilityCount} capabilities`);
     * ```
     */
    get capabilityCount(): number;
    /**
     * Clear all indexed data.
     *
     * @example
     * ```typescript
     * index.clear();
     * // All mappings reset
     * ```
     */
    clear(): void;
}
//# sourceMappingURL=capability-index.d.ts.map