@tdsoft-tech/aikit 0.1.2

package/dist/index.d.ts

@@ -0,0 +1,1000 @@
+import { z } from 'zod';
+
+/**
+ * AIKit Configuration Schema
+ */
+declare const ConfigSchema: z.ZodObject<{
+    version: z.ZodString;
+    skills: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        directory: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        directory?: string | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        directory?: string | undefined;
+    }>>;
+    agents: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        default: string;
+        enabled: boolean;
+    }, {
+        default?: string | undefined;
+        enabled?: boolean | undefined;
+    }>>;
+    commands: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+    tools: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+    plugins: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        autoload: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        autoload?: string[] | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        autoload?: string[] | undefined;
+    }>>;
+    memory: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxSize: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        maxSize?: number | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        maxSize?: number | undefined;
+    }>>;
+    beads: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        autoInit: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        autoInit: boolean;
+    }, {
+        enabled?: boolean | undefined;
+        autoInit?: boolean | undefined;
+    }>>;
+    antiHallucination: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        specFile: z.ZodDefault<z.ZodString>;
+        reviewFile: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        specFile: string;
+        reviewFile: string;
+    }, {
+        enabled?: boolean | undefined;
+        specFile?: string | undefined;
+        reviewFile?: string | undefined;
+    }>>;
+    mcp: z.ZodOptional<z.ZodObject<{
+        context7: z.ZodDefault<z.ZodBoolean>;
+        githubGrep: z.ZodDefault<z.ZodBoolean>;
+        gkg: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        context7: boolean;
+        githubGrep: boolean;
+        gkg: boolean;
+    }, {
+        context7?: boolean | undefined;
+        githubGrep?: boolean | undefined;
+        gkg?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    skills: {
+        enabled: boolean;
+        directory?: string | undefined;
+    };
+    agents: {
+        default: string;
+        enabled: boolean;
+    };
+    commands: {
+        enabled: boolean;
+    };
+    tools: {
+        enabled: boolean;
+    };
+    plugins: {
+        enabled: boolean;
+        autoload?: string[] | undefined;
+    };
+    memory: {
+        enabled: boolean;
+        maxSize?: number | undefined;
+    };
+    beads: {
+        enabled: boolean;
+        autoInit: boolean;
+    };
+    version: string;
+    antiHallucination: {
+        enabled: boolean;
+        specFile: string;
+        reviewFile: string;
+    };
+    mcp?: {
+        context7: boolean;
+        githubGrep: boolean;
+        gkg: boolean;
+    } | undefined;
+}, {
+    version: string;
+    skills?: {
+        enabled?: boolean | undefined;
+        directory?: string | undefined;
+    } | undefined;
+    agents?: {
+        default?: string | undefined;
+        enabled?: boolean | undefined;
+    } | undefined;
+    commands?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+    tools?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+    plugins?: {
+        enabled?: boolean | undefined;
+        autoload?: string[] | undefined;
+    } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        maxSize?: number | undefined;
+    } | undefined;
+    beads?: {
+        enabled?: boolean | undefined;
+        autoInit?: boolean | undefined;
+    } | undefined;
+    antiHallucination?: {
+        enabled?: boolean | undefined;
+        specFile?: string | undefined;
+        reviewFile?: string | undefined;
+    } | undefined;
+    mcp?: {
+        context7?: boolean | undefined;
+        githubGrep?: boolean | undefined;
+        gkg?: boolean | undefined;
+    } | undefined;
+}>;
+type AIKitConfig = z.infer<typeof ConfigSchema> & {
+    configPath: string;
+    projectPath: string;
+};
+/**
+ * Configuration manager for AIKit
+ */
+declare class Config {
+    private config;
+    constructor(config: AIKitConfig);
+    get(): AIKitConfig;
+    get skills(): {
+        enabled: boolean;
+        directory?: string | undefined;
+    };
+    get agents(): {
+        default: string;
+        enabled: boolean;
+    };
+    get commands(): {
+        enabled: boolean;
+    };
+    get tools(): {
+        enabled: boolean;
+    };
+    get plugins(): {
+        enabled: boolean;
+        autoload?: string[] | undefined;
+    };
+    get memory(): {
+        enabled: boolean;
+        maxSize?: number | undefined;
+    };
+    get beads(): {
+        enabled: boolean;
+        autoInit: boolean;
+    };
+    get antiHallucination(): {
+        enabled: boolean;
+        specFile: string;
+        reviewFile: string;
+    };
+    get configPath(): string;
+    get projectPath(): string;
+    /**
+     * Get path to a specific resource
+     */
+    getPath(resource: 'skills' | 'agents' | 'commands' | 'tools' | 'plugins' | 'memory'): string;
+}
+/**
+ * Load AIKit configuration
+ * Merges project-level config with global config (project takes precedence)
+ */
+declare function loadConfig(projectPath?: string): Promise<Config>;
+
+/**
+ * Skill definition
+ */
+interface Skill {
+    name: string;
+    description: string;
+    useWhen: string;
+    category: string;
+    tags: string[];
+    content: string;
+    filePath: string;
+}
+/**
+ * Skill Engine - Manages workflow skills for AI agents
+ *
+ * Skills are mandatory workflow instructions that agents must follow.
+ * They enforce structured processes like TDD, systematic debugging, etc.
+ */
+declare class SkillEngine {
+    private config;
+    private skillsCache;
+    constructor(config: Config);
+    /**
+     * List all available skills
+     */
+    listSkills(): Promise<Skill[]>;
+    /**
+     * Get a specific skill by name
+     */
+    getSkill(name: string): Promise<Skill | null>;
+    /**
+     * Find skills matching a query
+     */
+    findSkills(query?: string): Promise<Skill[]>;
+    /**
+     * Create a new skill
+     */
+    createSkill(name: string, options?: {
+        description?: string;
+        useWhen?: string;
+        category?: string;
+        tags?: string[];
+        content?: string;
+        global?: boolean;
+    }): Promise<Skill>;
+    /**
+     * Sync global skills to project directory
+     */
+    syncSkillsToProject(): Promise<{
+        count: number;
+        synced: string[];
+    }>;
+    /**
+     * Format skill for agent consumption
+     */
+    formatForAgent(skill: Skill): string;
+    /**
+     * Load skills from a directory
+     */
+    private loadSkillsFromDir;
+}
+
+/**
+ * Agent types available in AIKit
+ */
+type AgentType = 'planner' | 'build' | 'rush' | 'review' | 'scout' | 'explore' | 'vision';
+/**
+ * Agent definition
+ */
+interface Agent {
+    name: AgentType;
+    displayName: string;
+    description: string;
+    useWhen: string;
+    capabilities: string[];
+    systemPrompt: string;
+    delegatesTo: AgentType[];
+}
+/**
+ * Agent delegation result
+ */
+interface DelegationDecision {
+    agent: Agent;
+    reason: string;
+    shouldDelegate: boolean;
+    subTasks?: string[];
+}
+/**
+ * Agent Manager - Handles agent selection and delegation
+ */
+declare class AgentManager {
+    private config;
+    private agents;
+    constructor(config: Config);
+    /**
+     * List all available agents
+     */
+    listAgents(): Agent[];
+    /**
+     * Get a specific agent
+     */
+    getAgent(name: AgentType): Agent | undefined;
+    /**
+     * Get the default agent
+     */
+    getDefaultAgent(): Agent;
+    /**
+     * Decide which agent should handle a task
+     */
+    decideAgent(task: string, _context?: string): DelegationDecision;
+    /**
+     * Format agent instructions for prompt
+     */
+    formatAgentPrompt(agent: Agent): string;
+    private matchesKeywords;
+}
+
+/**
+ * Command definition
+ */
+interface Command {
+    name: string;
+    description: string;
+    category: string;
+    usage: string;
+    examples: string[];
+    content: string;
+    filePath: string;
+}
+/**
+ * Command Runner - Manages and executes slash commands
+ */
+declare class CommandRunner {
+    private config;
+    private commandsCache;
+    constructor(config: Config);
+    /**
+     * List all available commands
+     */
+    listCommands(): Promise<Command[]>;
+    /**
+     * Get a specific command
+     */
+    getCommand(name: string): Promise<Command | null>;
+    /**
+     * Create a custom command
+     */
+    createCommand(name: string, options?: {
+        description?: string;
+        category?: string;
+        usage?: string;
+        examples?: string[];
+        content?: string;
+        global?: boolean;
+    }): Promise<Command>;
+    /**
+     * Format command for agent consumption
+     */
+    formatForAgent(command: Command): string;
+    /**
+     * Load commands from directory (recursively)
+     */
+    private loadCommandsFromDir;
+}
+
+/**
+ * Tool configuration status
+ */
+type ToolStatus = 'ready' | 'needs_config' | 'error';
+/**
+ * Tool configuration schema
+ */
+declare const ToolConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodEnum<["ready", "needs_config", "error"]>;
+    description: z.ZodString;
+    configMethod: z.ZodEnum<["oauth", "manual", "none"]>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "ready" | "needs_config" | "error";
+    name: string;
+    description: string;
+    configMethod: "oauth" | "manual" | "none";
+    config?: Record<string, unknown> | undefined;
+    errorMessage?: string | undefined;
+}, {
+    status: "ready" | "needs_config" | "error";
+    name: string;
+    description: string;
+    configMethod: "oauth" | "manual" | "none";
+    config?: Record<string, unknown> | undefined;
+    errorMessage?: string | undefined;
+}>;
+type ToolConfig = z.infer<typeof ToolConfigSchema>;
+/**
+ * Tool Configuration Manager
+ */
+declare class ToolConfigManager {
+    private config;
+    private toolsConfigPath;
+    constructor(config: Config);
+    /**
+     * Get all registered tools with their current status
+     */
+    listTools(): Promise<ToolConfig[]>;
+    /**
+     * Get configuration for a specific tool
+     */
+    getToolConfig(toolName: string): Promise<ToolConfig | null>;
+    /**
+     * Update tool configuration
+     */
+    updateToolConfig(toolName: string, updates: {
+        config?: Record<string, unknown>;
+        status?: ToolStatus;
+        errorMessage?: string;
+    }): Promise<void>;
+    /**
+     * Check if a tool is ready to use
+     */
+    isToolReady(toolName: string): Promise<boolean>;
+    /**
+     * Get API key for a tool (if configured)
+     */
+    getApiKey(toolName: string): Promise<string | null>;
+    /**
+     * Determine tool status based on configuration
+     */
+    private determineStatus;
+    /**
+     * Load saved configurations
+     */
+    private loadConfigs;
+    /**
+     * Save configurations
+     */
+    private saveConfigs;
+}
+
+/**
+ * Tool argument schema
+ */
+declare const ToolArgSchema: z.ZodObject<{
+    type: z.ZodEnum<["string", "number", "boolean", "array", "object"]>;
+    description: z.ZodString;
+    required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    default: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    description: string;
+    required: boolean;
+    default?: any;
+}, {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    description: string;
+    default?: any;
+    required?: boolean | undefined;
+}>;
+type ToolArg = z.infer<typeof ToolArgSchema>;
+/**
+ * Tool definition
+ */
+interface Tool {
+    name: string;
+    description: string;
+    args: Record<string, ToolArg>;
+    execute: (args: Record<string, unknown>) => Promise<string>;
+    filePath?: string;
+}
+/**
+ * Tool definition helper for type safety
+ */
+declare function defineTool(config: {
+    name: string;
+    description: string;
+    args: Record<string, ToolArg>;
+    execute: (args: Record<string, unknown>) => Promise<string>;
+}): Tool;
+/**
+ * Tool Registry - Manages custom tools for AI agents
+ */
+declare class ToolRegistry {
+    private config;
+    private tools;
+    private toolConfigManager?;
+    constructor(config: Config);
+    /**
+     * Set tool config manager (for tools that need configuration)
+     */
+    setToolConfigManager(manager: ToolConfigManager): void;
+    /**
+     * List all available tools
+     */
+    listTools(): Promise<Tool[]>;
+    /**
+     * Get a specific tool
+     */
+    getTool(name: string): Tool | undefined;
+    /**
+     * Register a new tool
+     */
+    registerTool(tool: Tool): void;
+    /**
+     * Execute a tool
+     */
+    executeTool(name: string, args: Record<string, unknown>, context?: {
+        toolConfigManager?: ToolConfigManager;
+    }): Promise<string>;
+    /**
+     * Create a custom tool
+     */
+    createTool(name: string, options: {
+        description: string;
+        args: Record<string, ToolArg>;
+        code: string;
+        global?: boolean;
+    }): Promise<void>;
+    /**
+     * Format tool for agent consumption
+     */
+    formatForAgent(tool: Tool): string;
+    /**
+     * Load custom tools from disk
+     */
+    private loadCustomTools;
+    private loadToolsFromDir;
+}
+
+/**
+ * Plugin event types
+ */
+type PluginEventType = 'session.idle' | 'session.created' | 'session.error' | 'tool.execute.before' | 'tool.execute.after' | 'file.edited' | 'file.watcher.updated' | 'message.updated' | 'message.removed';
+/**
+ * Plugin event payload
+ */
+interface PluginEvent {
+    type: PluginEventType;
+    timestamp: Date;
+    properties?: Record<string, unknown>;
+}
+/**
+ * Plugin context passed to plugins
+ */
+interface PluginContext {
+    project: {
+        path: string;
+        name: string;
+    };
+    config: Config;
+    emit: (event: PluginEvent) => Promise<void>;
+}
+/**
+ * Plugin handler return type
+ */
+interface PluginHandlers {
+    event?: (event: PluginEvent) => Promise<void>;
+    'tool.execute.before'?: (input: unknown) => Promise<unknown>;
+    'tool.execute.after'?: (input: unknown, output: unknown) => Promise<unknown>;
+}
+/**
+ * Plugin definition function type
+ */
+type PluginFactory = (context: PluginContext) => Promise<PluginHandlers>;
+/**
+ * Plugin metadata
+ */
+interface PluginInfo {
+    name: string;
+    description: string;
+    enabled: boolean;
+    filePath: string;
+    handlers?: PluginHandlers;
+}
+/**
+ * Plugin definition helper
+ */
+type Plugin = PluginFactory;
+/**
+ * Plugin System - Manages event-driven plugins
+ */
+declare class PluginSystem {
+    private config;
+    private plugins;
+    private loadedPlugins;
+    private eventQueue;
+    private processing;
+    constructor(config: Config);
+    /**
+     * Initialize and load all plugins
+     */
+    initialize(): Promise<void>;
+    /**
+     * List all available plugins
+     */
+    listPlugins(): Promise<PluginInfo[]>;
+    /**
+     * Enable a plugin
+     */
+    enablePlugin(name: string): Promise<void>;
+    /**
+     * Disable a plugin
+     */
+    disablePlugin(name: string): void;
+    /**
+     * Emit an event to all plugins
+     */
+    emit(event: PluginEvent): Promise<void>;
+    /**
+     * Execute before hooks for tool execution
+     */
+    executeBeforeHooks(_toolName: string, input: unknown): Promise<unknown>;
+    /**
+     * Execute after hooks for tool execution
+     */
+    executeAfterHooks(_toolName: string, input: unknown, output: unknown): Promise<unknown>;
+    /**
+     * Create a new plugin
+     */
+    createPlugin(name: string, options: {
+        description?: string;
+        code: string;
+        global?: boolean;
+    }): Promise<void>;
+    /**
+     * Process event queue
+     */
+    private processEventQueue;
+    /**
+     * Load plugins from disk
+     */
+    private loadPlugins;
+    private registerBuiltInPlugins;
+    private loadPluginsFromDir;
+    private initializePlugin;
+    private getBuiltInPluginHandlers;
+}
+
+/**
+ * Memory entry structure
+ */
+interface Memory {
+    key: string;
+    content: string;
+    summary: string;
+    createdAt: Date;
+    updatedAt: Date;
+    type: 'observation' | 'handoff' | 'research' | 'template' | 'custom';
+}
+/**
+ * Memory Manager - Persistent context across sessions
+ */
+declare class MemoryManager {
+    private config;
+    constructor(config: Config);
+    /**
+     * List all memory entries
+     */
+    list(): Promise<Memory[]>;
+    /**
+     * Read a memory entry
+     */
+    read(key: string): Promise<string | null>;
+    /**
+     * Update a memory entry
+     */
+    update(key: string, content: string, options?: {
+        append?: boolean;
+        type?: Memory['type'];
+    }): Promise<void>;
+    /**
+     * Create a handoff bundle
+     */
+    createHandoff(summary: {
+        completed: string[];
+        inProgress: string[];
+        remaining: string[];
+        context: string;
+        nextSteps: string[];
+    }): Promise<string>;
+    /**
+     * Get the latest handoff
+     */
+    getLatestHandoff(): Promise<Memory | null>;
+    /**
+     * Create an observation
+     */
+    createObservation(title: string, observation: {
+        what: string;
+        why: string;
+        impact: string;
+        tags?: string[];
+    }): Promise<string>;
+    /**
+     * Save research findings
+     */
+    saveResearch(topic: string, findings: {
+        summary: string;
+        sources: string[];
+        recommendations: string[];
+        codeExamples?: string;
+    }): Promise<string>;
+    /**
+     * Extract a summary from content (first paragraph or heading)
+     */
+    private extractSummary;
+}
+
+/**
+ * Bead task structure
+ */
+interface Bead {
+    id: string;
+    title: string;
+    description: string;
+    status: 'todo' | 'in-progress' | 'completed' | 'blocked';
+    createdAt: Date;
+    updatedAt: Date;
+    notes: string[];
+    subtasks?: string[];
+}
+/**
+ * Beads integration status
+ */
+interface BeadsStatus {
+    installed: boolean;
+    version?: string;
+    initialized: boolean;
+    activeTasks: number;
+    completedTasks: number;
+    currentTask?: string;
+}
+/**
+ * Beads Integration - Task tracking with hard quality gates
+ */
+declare class BeadsIntegration {
+    private projectPath;
+    constructor(projectPath?: string);
+    /**
+     * Check if Beads CLI is installed
+     */
+    isInstalled(): Promise<boolean>;
+    /**
+     * Get Beads version
+     */
+    getVersion(): Promise<string | null>;
+    /**
+     * Check if Beads is initialized in project
+     */
+    isInitialized(): Promise<boolean>;
+    /**
+     * Initialize Beads in project
+     */
+    init(): Promise<boolean>;
+    /**
+     * Get current status
+     */
+    getStatus(): Promise<BeadsStatus>;
+    /**
+     * List all beads in the project
+     */
+    listBeads(): Promise<Bead[]>;
+    /**
+     * Get a specific bead
+     */
+    getBead(id: string): Promise<Bead | null>;
+    /**
+     * Create a new bead
+     */
+    createBead(title: string, description: string): Promise<Bead>;
+    /**
+     * Update bead status
+     */
+    updateBeadStatus(id: string, status: Bead['status']): Promise<boolean>;
+    /**
+     * Add note to bead
+     */
+    addNote(id: string, note: string): Promise<boolean>;
+    /**
+     * Complete a bead with quality gates
+     */
+    completeBead(id: string): Promise<{
+        success: boolean;
+        gates: {
+            name: string;
+            passed: boolean;
+            error?: string;
+        }[];
+    }>;
+    /**
+     * Get current active bead
+     */
+    getCurrentBead(): Promise<Bead | null>;
+    /**
+     * Parse a bead file
+     */
+    private parseBeadFile;
+}
+
+/**
+ * Spec violation
+ */
+interface SpecViolation {
+    rule: string;
+    description: string;
+    severity: 'error' | 'warning';
+    location?: string;
+}
+/**
+ * Anti-Hallucination System
+ *
+ * Prevents AI from inventing APIs, assuming features, and losing track of requirements.
+ * Implements three validation layers:
+ * 1. Task Validation (.beads/ tracking)
+ * 2. Spec Enforcement (spec.md constraints)
+ * 3. Review Gates (review.md documentation)
+ */
+declare class AntiHallucination {
+    private config;
+    constructor(config: Config);
+    /**
+     * Layer 1: Validate task exists before work begins
+     */
+    validateTask(taskId?: string): Promise<{
+        valid: boolean;
+        task?: {
+            id: string;
+            description: string;
+            status: string;
+        };
+        error?: string;
+    }>;
+    /**
+     * Layer 2: Check spec constraints
+     */
+    checkSpec(): Promise<{
+        hasSpec: boolean;
+        constraints?: {
+            naming: string[];
+            forbidden: string[];
+            required: string[];
+        };
+    }>;
+    /**
+     * Validate code against spec constraints
+     */
+    validateAgainstSpec(code: string, filePath: string): Promise<SpecViolation[]>;
+    /**
+     * Layer 3: Create review documentation
+     */
+    createReview(changes: {
+        filesChanged: string[];
+        functionsAdded: string[];
+        testsAdded: string[];
+        skipped?: string[];
+        inconsistencies?: string[];
+    }): Promise<string>;
+    /**
+     * Verify completion (hard gates)
+     */
+    verifyCompletion(): Promise<{
+        passed: boolean;
+        gates: {
+            name: string;
+            passed: boolean;
+            error?: string;
+        }[];
+    }>;
+    /**
+     * Recovery: Check for context loss
+     */
+    checkContextLoss(): Promise<{
+        hasHandoff: boolean;
+        latestHandoff?: string;
+    }>;
+    /**
+     * Initialize spec.md template
+     */
+    initSpec(): Promise<void>;
+    /**
+     * Extract constraints from a section
+     */
+    private extractConstraints;
+    /**
+     * Convert a constraint description to a regex pattern
+     */
+    private patternToRegex;
+}
+
+/**
+ * Simple logger with colored output
+ */
+declare const logger: {
+    info(...args: unknown[]): void;
+    success(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    step(step: number, total: number, message: string): void;
+    header(message: string): void;
+    list(items: string[], prefix?: string): void;
+};
+
+/**
+ * Path utilities for AIKit configuration and data directories
+ */
+declare const paths: {
+    /**
+     * Get the global AIKit configuration directory
+     * ~/.config/aikit/ on Unix, %APPDATA%/aikit/ on Windows
+     */
+    globalConfig(): string;
+    /**
+     * Get the project-level AIKit configuration directory
+     */
+    projectConfig(projectPath?: string): string;
+    /**
+     * Get the OpenCode configuration directory
+     */
+    opencodeConfig(): string;
+    /**
+     * Get the Beads directory for the current project
+     */
+    beadsDir(projectPath?: string): string;
+    /**
+     * Check if a project has AIKit initialized
+     */
+    hasProjectConfig(projectPath?: string): boolean;
+    /**
+     * Check if global AIKit is initialized
+     */
+    hasGlobalConfig(): boolean;
+    /**
+     * Get effective config path (project takes precedence over global)
+     */
+    effectiveConfig(projectPath?: string): string | null;
+    /**
+     * Get skills directory
+     */
+    skills(configPath: string): string;
+    /**
+     * Get agents directory
+     */
+    agents(configPath: string): string;
+    /**
+     * Get commands directory
+     */
+    commands(configPath: string): string;
+    /**
+     * Get tools directory
+     */
+    tools(configPath: string): string;
+    /**
+     * Get plugins directory
+     */
+    plugins(configPath: string): string;
+    /**
+     * Get memory directory
+     */
+    memory(configPath: string): string;
+};
+
+/**
+ * AIKit - Open-source AI coding agent toolkit for OpenCode
+ *
+ * Provides skills, agents, commands, tools, and plugins for enhanced AI-assisted development.
+ */
+
+declare const VERSION = "0.1.0";
+
+export { type AIKitConfig, type Agent, AgentManager, type AgentType, AntiHallucination, BeadsIntegration, type Command, CommandRunner, Config, type Memory, MemoryManager, type Plugin, type PluginEvent, PluginSystem, type Skill, SkillEngine, type Tool, ToolRegistry, VERSION, defineTool, loadConfig, logger, paths };