ccjk 1.3.1

package/dist/index.d.mts

@@ -0,0 +1,2644 @@
+import * as ansis from 'ansis';
+
+declare const CLAUDE_DIR: string;
+declare const SETTINGS_FILE: string;
+declare const CLAUDE_MD_FILE: string;
+declare const ClAUDE_CONFIG_FILE: string;
+declare const CLAUDE_VSC_CONFIG_FILE: string;
+declare const CODEX_DIR: string;
+declare const CODEX_CONFIG_FILE: string;
+declare const CODEX_AUTH_FILE: string;
+declare const CODEX_AGENTS_FILE: string;
+declare const CODEX_PROMPTS_DIR: string;
+declare const AIDER_DIR: string;
+declare const AIDER_CONFIG_FILE: string;
+declare const AIDER_ENV_FILE: string;
+declare const CONTINUE_DIR: string;
+declare const CONTINUE_CONFIG_FILE: string;
+declare const CLINE_DIR: string;
+declare const CLINE_CONFIG_FILE: string;
+declare const CURSOR_DIR: string;
+declare const CURSOR_CONFIG_FILE: string;
+declare const CCJK_CONFIG_DIR: string;
+declare const CCJK_CONFIG_FILE: string;
+declare const CCJK_PLUGINS_DIR: string;
+declare const CCJK_SKILLS_DIR: string;
+declare const CCJK_GROUPS_DIR: string;
+declare const LEGACY_ZCF_CONFIG_DIR: string;
+declare const LEGACY_ZCF_CONFIG_FILE: string;
+declare const LEGACY_ZCF_CONFIG_FILES: string[];
+/** @deprecated Use CCJK_CONFIG_DIR instead */
+declare const ZCF_CONFIG_DIR: string;
+/** @deprecated Use CCJK_CONFIG_FILE instead */
+declare const ZCF_CONFIG_FILE: string;
+declare const CODE_TOOL_TYPES: readonly ["claude-code", "codex", "aider", "continue", "cline", "cursor"];
+type CodeToolType = (typeof CODE_TOOL_TYPES)[number];
+declare const DEFAULT_CODE_TOOL_TYPE: CodeToolType;
+declare const CODE_TOOL_BANNERS: Record<CodeToolType, string>;
+declare const CODE_TOOL_ALIASES: Record<string, CodeToolType>;
+declare const CODE_TOOL_INFO: Record<CodeToolType, {
+    name: string;
+    description: string;
+    website: string;
+    installCmd: string;
+    configFormat: 'json' | 'toml' | 'yaml';
+    category: 'cli' | 'extension' | 'editor';
+}>;
+declare function isCodeToolType(value: any): value is CodeToolType;
+declare const API_DEFAULT_URL = "https://api.anthropic.com";
+declare const API_ENV_KEY = "ANTHROPIC_API_KEY";
+declare function resolveCodeToolType(value: unknown): CodeToolType;
+declare const SUPPORTED_LANGS: readonly ["zh-CN", "en"];
+type SupportedLang = (typeof SUPPORTED_LANGS)[number];
+declare const LANG_LABELS: {
+    readonly 'zh-CN': "简体中文";
+    readonly en: "English";
+};
+declare const AI_OUTPUT_LANGUAGES: {
+    readonly 'zh-CN': {
+        readonly directive: "Always respond in Chinese-simplified";
+    };
+    readonly en: {
+        readonly directive: "Always respond in English";
+    };
+    readonly custom: {
+        readonly directive: "";
+    };
+};
+type AiOutputLanguage = keyof typeof AI_OUTPUT_LANGUAGES;
+declare function getAiOutputLanguageLabel(lang: AiOutputLanguage): string;
+
+interface InitOptions {
+    configLang?: SupportedLang;
+    aiOutputLang?: AiOutputLanguage | string;
+    force?: boolean;
+    skipBanner?: boolean;
+    skipPrompt?: boolean;
+    codeType?: CodeToolType | string;
+    configAction?: 'new' | 'backup' | 'merge' | 'docs-only' | 'skip';
+    apiType?: 'auth_token' | 'api_key' | 'ccr_proxy' | 'skip';
+    apiKey?: string;
+    apiUrl?: string;
+    apiModel?: string;
+    apiHaikuModel?: string;
+    apiSonnetModel?: string;
+    apiOpusModel?: string;
+    provider?: string;
+    mcpServices?: string[] | string | boolean;
+    workflows?: string[] | string | boolean;
+    outputStyles?: string[] | string | boolean;
+    defaultOutputStyle?: string;
+    allLang?: string;
+    installCometixLine?: string | boolean;
+    apiConfigs?: string;
+    apiConfigsFile?: string;
+}
+declare function init(options?: InitOptions): Promise<void>;
+
+/**
+ * Skill category types
+ */
+type SkillCategory = 'git' | 'dev' | 'seo' | 'devops' | 'testing' | 'docs' | 'review' | 'custom';
+/**
+ * Skill definition interface
+ */
+interface CcjkSkill {
+    /** Unique skill identifier */
+    id: string;
+    /** Localized skill name */
+    name: Record<SupportedLang, string>;
+    /** Localized skill description */
+    description: Record<SupportedLang, string>;
+    /** Skill category */
+    category: SkillCategory;
+    /** Command triggers (e.g., /ts-debug, /py-test) */
+    triggers: string[];
+    /** Skill template content (markdown) */
+    template: string;
+    /** Associated agent IDs */
+    agents?: string[];
+    /** Whether skill is enabled */
+    enabled: boolean;
+    /** Skill version */
+    version: string;
+    /** Author information */
+    author?: string;
+    /** Tags for search/filtering */
+    tags?: string[];
+}
+/**
+ * Batch skill creation options
+ */
+interface BatchSkillOptions {
+    /** Language-specific skills */
+    lang?: 'typescript' | 'python' | 'rust' | 'go' | 'java' | 'ruby';
+    /** Site-type specific skills */
+    site?: 'ecommerce' | 'saas' | 'blog' | 'api' | 'dashboard';
+    /** SEO skills */
+    seo?: boolean;
+    /** DevOps skills */
+    devops?: boolean;
+    /** Custom category */
+    customCategory?: string;
+    /** Output directory */
+    outputDir?: string;
+}
+/**
+ * Batch skill template definition
+ */
+interface BatchSkillTemplate {
+    category: SkillCategory;
+    skills: Array<{
+        id: string;
+        name: Record<SupportedLang, string>;
+        description: Record<SupportedLang, string>;
+        triggers: string[];
+        templateFile: string;
+        agents?: string[];
+        tags?: string[];
+    }>;
+}
+/**
+ * Skill installation result
+ */
+interface SkillInstallResult {
+    skillId: string;
+    success: boolean;
+    path?: string;
+    error?: string;
+}
+/**
+ * Skill registry state
+ */
+interface SkillRegistry {
+    skills: Map<string, CcjkSkill>;
+    categories: Map<SkillCategory, string[]>;
+    lastUpdated: Date;
+}
+/**
+ * Skill search options
+ */
+interface SkillSearchOptions {
+    query?: string;
+    category?: SkillCategory;
+    tags?: string[];
+    enabled?: boolean;
+    limit?: number;
+}
+/**
+ * Skill export format
+ */
+interface SkillExport {
+    version: string;
+    exportedAt: string;
+    skills: CcjkSkill[];
+}
+
+/**
+ * Plugin metadata
+ */
+interface PluginMetadata {
+    /** Plugin unique name */
+    name: string;
+    /** Plugin version (semver) */
+    version: string;
+    /** Plugin description */
+    description: string;
+    /** Plugin author */
+    author?: string;
+    /** Plugin homepage */
+    homepage?: string;
+    /** Plugin license */
+    license?: string;
+    /** Minimum CCJK version required */
+    minCcjkVersion?: string;
+    /** Plugin keywords for discovery */
+    keywords?: string[];
+}
+/**
+ * Workflow extension provided by plugin
+ */
+interface WorkflowExtension {
+    id: string;
+    name: Record<SupportedLang, string>;
+    description?: Record<SupportedLang, string>;
+    category: string;
+    commands: string[];
+    agents?: Array<{
+        id: string;
+        filename: string;
+        required: boolean;
+    }>;
+    /** Template content or path relative to plugin */
+    templates: Record<SupportedLang, string>;
+}
+/**
+ * Agent extension provided by plugin
+ */
+interface AgentExtension {
+    id: string;
+    name: string;
+    description: string;
+    model: 'opus' | 'sonnet' | 'haiku' | 'inherit';
+    /** Agent definition content (markdown) */
+    definition: string;
+}
+/**
+ * MCP service extension provided by plugin
+ */
+interface McpServiceExtension {
+    id: string;
+    name: Record<SupportedLang, string>;
+    description?: Record<SupportedLang, string>;
+    requiresApiKey: boolean;
+    apiKeyEnvVar?: string;
+    config: {
+        type: 'stdio' | 'http';
+        command?: string;
+        args?: string[];
+        url?: string;
+        env?: Record<string, string>;
+    };
+}
+/**
+ * Output style extension provided by plugin
+ */
+interface OutputStyleExtension {
+    id: string;
+    name: Record<SupportedLang, string>;
+    description?: Record<SupportedLang, string>;
+    /** Style template content (markdown) */
+    template: string;
+}
+/**
+ * Command extension provided by plugin
+ */
+interface CommandExtension {
+    name: string;
+    description: string;
+    aliases?: string[];
+    options?: Array<{
+        name: string;
+        description: string;
+        type: 'string' | 'boolean' | 'number';
+        required?: boolean;
+        default?: any;
+    }>;
+    /** Handler function as string (will be evaluated) */
+    handler: string;
+}
+/**
+ * Plugin context passed to lifecycle hooks
+ */
+interface PluginContext {
+    /** CCJK version */
+    ccjkVersion: string;
+    /** Plugin config directory */
+    configDir: string;
+    /** i18n instance */
+    i18n: any;
+    /** Logger instance */
+    logger: PluginLogger;
+    /** Plugin storage */
+    storage: PluginStorage;
+}
+/**
+ * Plugin logger interface
+ */
+interface PluginLogger {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+    debug: (message: string) => void;
+}
+/**
+ * Plugin storage interface
+ */
+interface PluginStorage {
+    get: <T>(key: string) => T | undefined;
+    set: <T>(key: string, value: T) => void;
+    delete: (key: string) => void;
+    clear: () => void;
+}
+/**
+ * Main plugin interface
+ */
+interface CcjkPlugin {
+    /** Plugin metadata */
+    metadata: PluginMetadata;
+    /** Lifecycle: Called when plugin is loaded */
+    onLoad?: (context: PluginContext) => Promise<void>;
+    /** Lifecycle: Called when plugin is unloaded */
+    onUnload?: () => Promise<void>;
+    /** Lifecycle: Called when CCJK starts */
+    onStart?: (context: PluginContext) => Promise<void>;
+    /** Extension points */
+    workflows?: WorkflowExtension[];
+    agents?: AgentExtension[];
+    mcpServices?: McpServiceExtension[];
+    outputStyles?: OutputStyleExtension[];
+    commands?: CommandExtension[];
+    skills?: CcjkSkill[];
+    /** Configuration schema (JSON Schema) */
+    configSchema?: Record<string, any>;
+}
+/**
+ * Loaded plugin with runtime state
+ */
+interface LoadedPlugin {
+    plugin: CcjkPlugin;
+    path: string;
+    enabled: boolean;
+    loadedAt: Date;
+    error?: string;
+}
+/**
+ * Plugin registry entry
+ */
+interface PluginInfo {
+    name: string;
+    version: string;
+    description: string;
+    enabled: boolean;
+    path: string;
+    author?: string;
+}
+/**
+ * Plugin configuration
+ */
+interface PluginConfig {
+    /** List of enabled plugin names */
+    enabled: string[];
+    /** List of disabled plugin names */
+    disabled: string[];
+    /** Per-plugin settings */
+    settings: Record<string, Record<string, any>>;
+}
+/**
+ * Plugin discovery result
+ */
+interface PluginDiscoveryResult {
+    name: string;
+    path: string;
+    metadata: PluginMetadata;
+    valid: boolean;
+    error?: string;
+}
+
+/**
+ * Ensure plugins directory exists
+ */
+declare function ensurePluginsDir(): void;
+/**
+ * Read plugin configuration
+ */
+declare function readPluginConfig(): PluginConfig;
+/**
+ * Write plugin configuration
+ */
+declare function writePluginConfig(config: PluginConfig): void;
+/**
+ * Discover plugins in the plugins directory
+ */
+declare function discoverPlugins(): Promise<PluginDiscoveryResult[]>;
+/**
+ * Load a plugin
+ */
+declare function loadPlugin(pathOrName: string): Promise<LoadedPlugin | null>;
+/**
+ * Unload a plugin
+ */
+declare function unloadPlugin(name: string): Promise<boolean>;
+/**
+ * Get all loaded plugins
+ */
+declare function getLoadedPlugins(): LoadedPlugin[];
+/**
+ * Get plugin info
+ */
+declare function getPluginInfo(name: string): PluginInfo | null;
+/**
+ * List all plugins (loaded and discovered)
+ */
+declare function listPlugins(): Promise<PluginInfo[]>;
+/**
+ * Enable a plugin
+ */
+declare function enablePlugin(name: string): Promise<boolean>;
+/**
+ * Disable a plugin
+ */
+declare function disablePlugin(name: string): Promise<boolean>;
+/**
+ * Get all workflows from plugins
+ */
+declare function getPluginWorkflows(): any[];
+/**
+ * Get all agents from plugins
+ */
+declare function getPluginAgents(): any[];
+/**
+ * Get all MCP services from plugins
+ */
+declare function getPluginMcpServices(): any[];
+/**
+ * Get all output styles from plugins
+ */
+declare function getPluginOutputStyles(): any[];
+/**
+ * Get all skills from plugins
+ */
+declare function getPluginSkills(): any[];
+/**
+ * Initialize all enabled plugins
+ */
+declare function initializePlugins(): Promise<void>;
+
+/**
+ * Project context for LLM analysis
+ */
+interface ProjectContext$1 {
+    /** Project root path */
+    rootPath: string;
+    /** Project name */
+    projectName?: string;
+    /** Root directory */
+    rootDir?: string;
+    /** Detected language/framework */
+    framework?: string;
+    /** Detected frameworks */
+    frameworks?: string[];
+    /** Detected languages */
+    languages?: string[];
+    /** Package manager */
+    packageManager?: 'npm' | 'yarn' | 'pnpm' | 'bun';
+    /** Source directories */
+    sourceDirs: string[];
+    /** Test directories */
+    testDirs: string[];
+    /** Configuration files */
+    configFiles: string[];
+    /** File structure */
+    fileStructure?: string[];
+    /** Git information */
+    git?: {
+        branch: string;
+        lastCommit: string;
+        uncommittedChanges: number;
+    };
+}
+/**
+ * Scan target discovered by LLM
+ */
+interface ScanTarget {
+    /** Target type */
+    type: 'file' | 'directory' | 'function' | 'class' | 'module' | 'api' | 'config';
+    /** Target path */
+    path: string;
+    /** Reason for scanning */
+    reason: string;
+    /** Priority (1-10, 10 being highest) */
+    priority: number;
+    /** Estimated complexity */
+    complexity: 'low' | 'medium' | 'high';
+    /** Tags for categorization */
+    tags: string[];
+}
+/**
+ * Scan strategy determined by LLM
+ */
+interface ScanStrategy {
+    /** Strategy type */
+    type: 'security' | 'performance' | 'quality' | 'accessibility' | 'comprehensive';
+    /** Specific checks to perform */
+    checks: string[];
+    /** Depth of analysis */
+    depth: 'surface' | 'moderate' | 'deep';
+    /** Context to include */
+    contextFiles: string[];
+    /** LLM model to use */
+    model: 'opus' | 'sonnet' | 'haiku';
+    /** Focus areas */
+    focusAreas?: string[];
+}
+/**
+ * Scan result from LLM analysis
+ */
+interface ScanResult {
+    /** Target that was scanned */
+    target: ScanTarget;
+    /** Strategy used */
+    strategy: ScanStrategy;
+    /** Timestamp */
+    timestamp: Date;
+    /** Scanned at timestamp */
+    scannedAt?: Date;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Issues found */
+    issues: Issue[];
+    /** Metrics collected */
+    metrics: Record<string, number>;
+    /** LLM reasoning/notes */
+    notes: string;
+}
+/**
+ * Issue found during scan
+ */
+interface Issue {
+    /** Issue unique ID */
+    id: string;
+    /** Issue title */
+    title: string;
+    /** Detailed description */
+    description: string;
+    /** Severity level */
+    severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
+    /** Issue category */
+    category: 'security' | 'performance' | 'quality' | 'style' | 'accessibility' | 'logic';
+    /** Issue type */
+    type?: string;
+    /** File path */
+    file: string;
+    /** Line number (if applicable) */
+    line?: number;
+    /** Column number (if applicable) */
+    column?: number;
+    /** Code snippet */
+    snippet?: string;
+    /** Location info */
+    location?: {
+        file?: string;
+        startLine?: number;
+        endLine?: number;
+        column?: number;
+        snippet?: string;
+    } | string;
+    /** Suggested fix */
+    suggestedFix?: string;
+    /** Suggestion text */
+    suggestion?: string;
+    /** Whether auto-fix is safe */
+    autoFixable: boolean;
+    /** Related issues */
+    relatedIssues?: string[];
+    /** Confidence score (0-1) */
+    confidence: number;
+}
+/**
+ * Evaluated issue with LLM decision
+ */
+interface EvaluatedIssue extends Issue {
+    /** LLM evaluation reasoning */
+    evaluation: string;
+    /** Reasoning explanation */
+    reasoning?: string;
+    /** Actual priority (may differ from severity) */
+    priority: number;
+    /** Adjusted severity after evaluation */
+    adjustedSeverity?: 'critical' | 'high' | 'medium' | 'low' | 'info';
+    /** Whether this is a real issue */
+    isRealIssue?: boolean;
+    /** Risks associated */
+    risks?: string[];
+    /** Related patterns */
+    relatedPatterns?: string[];
+    /** Recommended action */
+    action: 'fix-now' | 'fix-later' | 'monitor' | 'ignore';
+    /** Effort estimate */
+    effort: 'trivial' | 'small' | 'medium' | 'large';
+}
+/**
+ * Fix decision from LLM
+ */
+interface FixDecision {
+    /** Whether to auto-fix */
+    shouldFix: boolean;
+    /** Whether can auto-fix */
+    canAutoFix?: boolean;
+    /** Whether requires review */
+    requiresReview?: boolean;
+    /** Risk level */
+    riskLevel?: 'none' | 'low' | 'medium' | 'high';
+    /** Reasoning */
+    reason: string;
+    /** Reasoning (alias) */
+    reasoning?: string;
+    /** Risk assessment */
+    risk: 'none' | 'low' | 'medium' | 'high';
+    /** Prerequisites before fixing */
+    prerequisites: string[];
+    /** Post-fix verification steps */
+    verificationSteps: string[];
+    /** Conditions for safe auto-fix */
+    conditions?: string[];
+    /** Alternative approaches */
+    alternatives?: string[];
+}
+/**
+ * Fix plan generated by LLM
+ */
+interface FixPlan {
+    /** Issue being fixed */
+    issueId: string;
+    /** Approach description */
+    approach: string;
+    /** Files to modify */
+    filesToModify: string[];
+    /** Expected changes description */
+    expectedChanges: string;
+    /** Rollback strategy */
+    rollbackStrategy: string;
+    /** Rollback plan */
+    rollbackPlan?: string;
+    /** Tests to run after fix */
+    testsToRun: string[];
+    /** Steps to execute */
+    steps?: Array<string | {
+        action: string;
+        description?: string;
+        order?: number;
+        target?: string;
+        changes?: string;
+    }>;
+    /** Validations to run */
+    validations?: string[];
+    /** Side effects */
+    sideEffects?: string[];
+    /** Test strategy */
+    testStrategy?: string;
+    /** Estimated duration in minutes */
+    estimatedDuration?: number;
+}
+/**
+ * Generated fix from LLM
+ */
+interface GeneratedFix {
+    /** Fix ID */
+    id?: string;
+    /** Issue ID */
+    issueId?: string;
+    /** Plan ID */
+    planId?: string;
+    /** Plan used */
+    plan: FixPlan;
+    /** File changes */
+    changes: FileChange[];
+    /** Commit message */
+    commitMessage: string;
+    /** Timestamp */
+    generatedAt: Date;
+    /** File path */
+    filePath?: string;
+    /** Fixed code */
+    fixedCode?: string;
+    /** Imports needed */
+    imports?: string[];
+    /** Warnings */
+    warnings?: string[];
+    /** Approach used */
+    approach?: string;
+    /** Description */
+    description?: string;
+    /** Pros */
+    pros?: string[];
+}
+/**
+ * File change in a fix
+ */
+interface FileChange {
+    /** File path */
+    path: string;
+    /** File reference */
+    file?: string;
+    /** Change type */
+    type: 'modify' | 'create' | 'delete' | 'rename';
+    /** Original content (for modify/delete) */
+    originalContent?: string;
+    /** New content (for modify/create) */
+    newContent?: string;
+    /** New path (for rename) */
+    newPath?: string;
+    /** Diff (unified format) */
+    diff?: string;
+    /** Start line */
+    startLine?: number;
+    /** End line */
+    endLine?: number;
+    /** Explanation */
+    explanation?: string;
+    /** Before content */
+    before?: string;
+    /** After content */
+    after?: string;
+}
+/**
+ * Fix application result
+ */
+interface FixResult {
+    /** Fix that was applied */
+    fix: GeneratedFix;
+    /** Fix ID */
+    fixId?: string;
+    /** Success status */
+    success: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Original content before fix */
+    originalContent?: string;
+    /** New content after fix */
+    newContent?: string;
+    /** Applied changes */
+    appliedChanges: FileChange[];
+    /** Failed changes */
+    failedChanges: Array<{
+        change: FileChange;
+        error: string;
+    }>;
+    /** Backup paths */
+    backupPaths: string[];
+    /** Timestamp */
+    appliedAt: Date;
+    /** Duration in ms */
+    duration?: number;
+    /** Changes applied count */
+    changesApplied?: number;
+}
+/**
+ * Verification result from LLM
+ */
+interface VerifyResult {
+    /** Fix ID that was verified */
+    fixId?: string;
+    /** Fix that was verified */
+    fix?: GeneratedFix;
+    /** Overall success */
+    success?: boolean;
+    /** Is the fix correct */
+    isCorrect?: boolean;
+    /** Issue resolved */
+    issueResolved?: boolean;
+    /** Syntax valid */
+    syntaxValid?: boolean;
+    /** Functionality preserved */
+    functionalityPreserved?: boolean;
+    /** Logic errors found */
+    logicErrors?: string[];
+    /** Edge cases handled */
+    edgeCasesHandled?: boolean;
+    /** Style consistent */
+    styleConsistent?: boolean;
+    /** Code correctness verified */
+    codeCorrect?: boolean;
+    /** No regressions detected */
+    noRegressions?: boolean;
+    /** No new issues introduced */
+    noNewIssues?: boolean;
+    /** Confidence score (0-1) */
+    confidence?: number;
+    /** Reasoning */
+    reasoning?: string;
+    /** Verification notes */
+    notes?: string;
+    /** Suggestions */
+    suggestions?: string[];
+    /** Recommendations */
+    recommendations?: string[];
+    /** Verified timestamp */
+    verifiedAt?: Date;
+}
+/**
+ * Regression found during verification
+ */
+interface Regression {
+    /** Type of regression */
+    type: 'functional' | 'performance' | 'breaking-change';
+    /** Description */
+    description: string;
+    /** Affected files */
+    affectedFiles: string[];
+    /** Severity */
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    /** File path */
+    file?: string;
+    /** Location */
+    location?: string;
+    /** Impact description */
+    impact?: string;
+    /** Suggestion for fix */
+    suggestion?: string;
+}
+/**
+ * New issue introduced by fix
+ */
+interface NewIssue extends Issue {
+    /** The fix that introduced this issue */
+    introducedByFix: string;
+}
+/**
+ * Execution plan for async audit
+ */
+interface ExecutionPlan {
+    /** Plan ID */
+    id: string;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Targets to scan */
+    targets: ScanTarget[];
+    /** Execution order */
+    order: string[];
+    /** Parallel execution groups */
+    parallelGroups: string[][];
+    /** Estimated duration */
+    estimatedDuration: number;
+    /** Total estimated minutes */
+    totalEstimatedMinutes?: number;
+    /** Priority queue */
+    priorityQueue: Array<{
+        targetId: string;
+        priority: number;
+    }>;
+    /** Execution phases */
+    phases?: Array<{
+        name: string;
+        description?: string;
+        targets: string[];
+        issueIds?: string[];
+        parallel?: boolean;
+        estimatedMinutes?: number;
+    }>;
+    /** Recommendations */
+    recommendations?: string[];
+    /** Issues to process */
+    issues?: string[];
+}
+/**
+ * ShenCha configuration
+ */
+interface ShenChaConfig {
+    /** Schedule configuration */
+    schedule: {
+        intervalHours: number;
+        totalDurationHours: number;
+        startTime?: string;
+    };
+    /** LLM configuration */
+    llm: {
+        baseUrl: string;
+        apiKey?: string;
+        models: {
+            scanning: string;
+            analysis: string;
+            fixing: string;
+        };
+        maxTokens?: number;
+        temperature?: number;
+    };
+    /** Scanner configuration */
+    scanners: {
+        page?: {
+            enabled: boolean;
+            criticalPages?: string[];
+        };
+        api?: {
+            enabled: boolean;
+            endpoints?: string[];
+        };
+        errorLog?: {
+            enabled: boolean;
+            lookbackHours?: number;
+        };
+        userBehavior?: {
+            enabled: boolean;
+            database?: string;
+        };
+    };
+    /** Fixer configuration */
+    fixer: {
+        enabled: boolean;
+        autoCommit: boolean;
+        safetyChecks: {
+            requireTypeCheck: boolean;
+            requireLintPass: boolean;
+            requireTestPass: boolean;
+            maxFilesPerFix: number;
+            maxLineChanges: number;
+            requireReview: string[];
+        };
+    };
+    /** Reporter configuration */
+    reporter: {
+        outputDir: string;
+        formats: Array<'markdown' | 'json' | 'html'>;
+        webhooks?: Array<{
+            url: string;
+            events: string[];
+        }>;
+    };
+}
+/**
+ * Audit cycle status
+ */
+interface AuditCycleStatus {
+    /** Cycle number */
+    cycleNumber: number;
+    /** Total cycles planned */
+    totalCycles: number;
+    /** Current status */
+    status: 'pending' | 'scanning' | 'analyzing' | 'fixing' | 'verifying' | 'completed' | 'failed';
+    /** Start time */
+    startedAt?: Date;
+    /** End time */
+    completedAt?: Date;
+    /** Issues found this cycle */
+    issuesFound: number;
+    /** Issues fixed this cycle */
+    issuesFixed: number;
+    /** Current target being processed */
+    currentTarget?: string;
+    /** Progress percentage */
+    progress: number;
+}
+/**
+ * Audit cycle
+ */
+interface AuditCycle {
+    /** Cycle ID */
+    id: string;
+    /** Start time */
+    startedAt: Date;
+    /** Completion time */
+    completedAt?: Date;
+    /** Current status */
+    status: 'pending' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+    /** Current phase */
+    currentPhase?: string;
+    /** Pause reason if paused */
+    pauseReason?: string;
+    /** Error message if failed */
+    error?: string;
+    /** Project context */
+    context: ProjectContext$1;
+    /** Scan results */
+    scanResults: ScanResult[];
+    /** Evaluated issues */
+    evaluatedIssues: EvaluatedIssue[];
+    /** Fix results */
+    fixResults: Array<{
+        issue: EvaluatedIssue;
+        plan: FixPlan;
+        fix: GeneratedFix;
+        result: FixResult;
+    }>;
+    /** Generated report */
+    report: AuditReport | null;
+}
+/**
+ * Audit report
+ */
+interface AuditReport {
+    /** Report ID */
+    id: string;
+    /** Cycle ID */
+    cycleId?: string;
+    /** Cycle number */
+    cycleNumber: number;
+    /** Generation timestamp */
+    generatedAt: Date;
+    /** Duration */
+    duration: number;
+    /** Summary */
+    summary: {
+        totalIssues: number;
+        fixedIssues: number;
+        pendingIssues: number;
+        pendingReview?: number;
+        failedFixes?: number;
+        bySeverity?: Record<string, number>;
+        byCategory?: Record<string, number>;
+        byType?: Record<string, number>;
+        healthScore?: number;
+        scores: {
+            security: number;
+            performance: number;
+            quality: number;
+        };
+    };
+    /** Issues by category */
+    issuesByCategory: Record<string, Issue[]>;
+    /** Issues list */
+    issues?: EvaluatedIssue[];
+    /** Fixes applied */
+    fixesApplied: FixResult[];
+    /** Fixes summary */
+    fixes?: Array<{
+        issueId: string;
+        success: boolean;
+        error?: string;
+    }>;
+    /** Recommendations */
+    recommendations: string[];
+    /** Next steps */
+    nextSteps: string[];
+}
+
+/**
+ * Initialize skills directory
+ */
+declare function ensureSkillsDir(): void;
+/**
+ * Get the skills registry
+ */
+declare function getRegistry$1(): SkillRegistry;
+/**
+ * Refresh registry from disk
+ */
+declare function refreshRegistry$1(): void;
+/**
+ * Get all skills
+ */
+declare function getAllSkills(): CcjkSkill[];
+/**
+ * Get skill by ID
+ */
+declare function getSkill(id: string): CcjkSkill | undefined;
+/**
+ * Search skills
+ */
+declare function searchSkills(options: SkillSearchOptions): CcjkSkill[];
+/**
+ * Add a skill
+ */
+declare function addSkill(skill: CcjkSkill): SkillInstallResult;
+/**
+ * Remove a skill
+ */
+declare function removeSkill(id: string): boolean;
+/**
+ * Enable/disable a skill
+ */
+declare function setSkillEnabled(id: string, enabled: boolean): boolean;
+/**
+ * Export skills to JSON
+ */
+declare function exportSkills(skillIds?: string[]): SkillExport;
+/**
+ * Import skills from JSON
+ */
+declare function importSkills(data: SkillExport): SkillInstallResult[];
+/**
+ * Create skills from batch template
+ */
+declare function createBatchSkills(options: BatchSkillOptions): SkillInstallResult[];
+/**
+ * Get available batch categories
+ */
+declare function getBatchCategories(): string[];
+
+/**
+ * Subagent group category
+ */
+type GroupCategory = 'language' | 'site-type' | 'seo' | 'devops' | 'testing' | 'custom';
+/**
+ * Agent definition within a group
+ */
+interface AgentDefinition {
+    /** Agent unique ID */
+    id: string;
+    /** Agent name */
+    name: string;
+    /** Agent description */
+    description: string;
+    /** Model to use */
+    model: 'opus' | 'sonnet' | 'haiku' | 'inherit';
+    /** Agent definition file content (markdown with YAML frontmatter) */
+    definition: string;
+    /** Whether agent is required in the group */
+    required: boolean;
+    /** Agent specialization tags */
+    tags?: string[];
+}
+/**
+ * Subagent group definition
+ */
+interface SubagentGroup {
+    /** Group unique ID */
+    id: string;
+    /** Localized group name */
+    name: Record<SupportedLang, string>;
+    /** Localized group description */
+    description: Record<SupportedLang, string>;
+    /** Group category */
+    category: GroupCategory;
+    /** Agents in this group */
+    agents: AgentDefinition[];
+    /** Associated skill IDs */
+    skills: string[];
+    /** Whether group is enabled by default */
+    defaultEnabled: boolean;
+    /** Group version */
+    version: string;
+    /** Group author */
+    author?: string;
+    /** Group icon (emoji or unicode) */
+    icon?: string;
+}
+/**
+ * Predefined language-specific groups
+ */
+type LanguageGroupId = 'typescript-dev' | 'python-dev' | 'rust-dev' | 'go-dev' | 'java-dev' | 'ruby-dev';
+/**
+ * Predefined site-type groups
+ */
+type SiteTypeGroupId = 'ecommerce' | 'saas' | 'blog-cms' | 'api-service' | 'dashboard' | 'mobile-app';
+/**
+ * Predefined specialty groups
+ */
+type SpecialtyGroupId = 'seo-team' | 'security-team' | 'performance-team' | 'testing-team' | 'devops-team';
+/**
+ * All predefined group IDs
+ */
+type PredefinedGroupId = LanguageGroupId | SiteTypeGroupId | SpecialtyGroupId;
+/**
+ * Group installation result
+ */
+interface GroupInstallResult {
+    groupId: string;
+    success: boolean;
+    installedAgents: string[];
+    installedSkills: string[];
+    errors?: string[];
+}
+/**
+ * Group registry state
+ */
+interface GroupRegistry {
+    groups: Map<string, SubagentGroup>;
+    enabledGroups: Set<string>;
+    lastUpdated: Date;
+}
+/**
+ * Group search options
+ */
+interface GroupSearchOptions {
+    query?: string;
+    category?: GroupCategory;
+    enabled?: boolean;
+    limit?: number;
+}
+/**
+ * Group export format
+ */
+interface GroupExport {
+    version: string;
+    exportedAt: string;
+    groups: SubagentGroup[];
+}
+/**
+ * Agent template for creating new agents in a group
+ */
+interface AgentTemplate {
+    category: GroupCategory;
+    name: string;
+    modelDefault: 'opus' | 'sonnet' | 'haiku';
+    responsibilities: string[];
+    allowedActions: string[];
+    forbiddenActions: string[];
+    technologies: string[];
+}
+
+/**
+ * Ensure groups directory exists
+ */
+declare function ensureGroupsDir(): void;
+/**
+ * Get the groups registry
+ */
+declare function getRegistry(): GroupRegistry;
+/**
+ * Refresh registry from disk
+ */
+declare function refreshRegistry(): void;
+/**
+ * Get all groups
+ */
+declare function getAllGroups(): SubagentGroup[];
+/**
+ * Get group by ID
+ */
+declare function getGroup(id: string): SubagentGroup | undefined;
+/**
+ * Check if group is enabled
+ */
+declare function isGroupEnabled(id: string): boolean;
+/**
+ * Search groups
+ */
+declare function searchGroups(options: GroupSearchOptions): SubagentGroup[];
+/**
+ * Enable a group
+ */
+declare function enableGroup(id: string): boolean;
+/**
+ * Disable a group
+ */
+declare function disableGroup(id: string): boolean;
+/**
+ * Add a custom group
+ */
+declare function addGroup(group: SubagentGroup): GroupInstallResult;
+/**
+ * Remove a group
+ */
+declare function removeGroup(id: string): boolean;
+/**
+ * Export groups
+ */
+declare function exportGroups(groupIds?: string[]): GroupExport;
+/**
+ * Import groups
+ */
+declare function importGroups(data: GroupExport): GroupInstallResult[];
+/**
+ * Get all enabled agents from all enabled groups
+ */
+declare function getEnabledAgents(): AgentDefinition[];
+/**
+ * Get all enabled skills from all enabled groups
+ */
+declare function getEnabledSkillIds(): string[];
+
+declare function getPlatform(): 'windows' | 'macos' | 'linux';
+declare function commandExists(command: string): Promise<boolean>;
+/**
+ * Get recommended install methods for a code tool based on current platform
+ * Returns methods in priority order (most recommended first)
+ */
+type CodeType = 'claude-code' | 'codex';
+type InstallMethod$1 = 'npm' | 'homebrew' | 'curl' | 'powershell' | 'cmd' | 'npm-global' | 'native';
+
+interface McpService {
+    id: string;
+    name: string;
+    description: string;
+    requiresApiKey: boolean;
+    apiKeyPrompt?: string;
+    apiKeyPlaceholder?: string;
+    apiKeyEnvVar?: string;
+    config: McpServerConfig;
+}
+interface McpServerConfig {
+    type: 'stdio' | 'sse';
+    command?: string;
+    args?: string[];
+    url?: string;
+    env?: Record<string, string>;
+    startup_timeout_ms?: number;
+}
+interface ClaudeConfiguration {
+    mcpServers: Record<string, McpServerConfig>;
+    hasCompletedOnboarding?: boolean;
+    customApiKeyResponses?: {
+        approved: string[];
+        rejected: string[];
+    };
+    env?: Record<string, string>;
+    primaryApiKey?: string;
+    installMethod?: InstallMethod$1;
+}
+
+/**
+ * CCJK API Router Types
+ * Unified type definitions for API routing modes
+ */
+/**
+ * API Routing Mode
+ */
+type ApiRoutingMode = 'official' | 'simple' | 'ccr';
+/**
+ * API Configuration Result
+ */
+interface ApiConfigResult {
+    success: boolean;
+    mode: ApiRoutingMode;
+    provider?: string;
+    message?: string;
+    error?: string;
+}
+
+/**
+ * Display current API configuration status
+ */
+declare function displayCurrentStatus(lang?: 'en' | 'zh-CN'): void;
+/**
+ * Interactive API configuration wizard
+ */
+declare function runConfigWizard(lang?: 'en' | 'zh-CN'): Promise<ApiConfigResult>;
+
+/**
+ * Detected project information
+ */
+interface ProjectInfo {
+    name: string;
+    type: ProjectType;
+    packageManager: PackageManager;
+    frameworks: Framework[];
+    buildTools: BuildTool[];
+    testFrameworks: TestFramework[];
+    cicd: CICDSystem[];
+    languages: Language[];
+    hasTypeScript: boolean;
+    hasDocker: boolean;
+    hasMonorepo: boolean;
+    rootDir: string;
+}
+/**
+ * Project type classification
+ */
+type ProjectType = 'frontend' | 'backend' | 'fullstack' | 'library' | 'cli' | 'mobile' | 'desktop' | 'unknown';
+/**
+ * Package managers
+ */
+type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'unknown';
+/**
+ * Frameworks
+ */
+type Framework = 'react' | 'vue' | 'angular' | 'svelte' | 'nextjs' | 'nuxt' | 'remix' | 'astro' | 'express' | 'fastify' | 'nestjs' | 'koa' | 'hono' | 'django' | 'flask' | 'fastapi' | 'rails' | 'laravel' | 'spring' | 'electron' | 'tauri' | 'react-native' | 'flutter' | 'unknown';
+/**
+ * Build tools
+ */
+type BuildTool = 'vite' | 'webpack' | 'rollup' | 'esbuild' | 'swc' | 'turbopack' | 'parcel' | 'tsup' | 'unbuild' | 'unknown';
+/**
+ * Test frameworks
+ */
+type TestFramework = 'jest' | 'vitest' | 'mocha' | 'cypress' | 'playwright' | 'pytest' | 'rspec' | 'junit' | 'unknown';
+/**
+ * CI/CD systems
+ */
+type CICDSystem = 'github-actions' | 'gitlab-ci' | 'jenkins' | 'circleci' | 'travis' | 'azure-pipelines' | 'unknown';
+/**
+ * Languages
+ */
+type Language = 'typescript' | 'javascript' | 'python' | 'ruby' | 'go' | 'rust' | 'java' | 'kotlin' | 'php' | 'csharp' | 'swift' | 'dart';
+/**
+ * Configuration suggestions
+ */
+interface ConfigSuggestions {
+    workflows: string[];
+    mcpServices: string[];
+    agents: string[];
+    skills: string[];
+    subagentGroups: string[];
+    outputStyle: string;
+}
+/**
+ * Detect package manager
+ */
+declare function detectPackageManager(dir: string): PackageManager;
+/**
+ * Detect frameworks from dependencies
+ */
+declare function detectFrameworks(dir: string): Framework[];
+/**
+ * Detect build tools
+ */
+declare function detectBuildTools(dir: string): BuildTool[];
+/**
+ * Detect test frameworks
+ */
+declare function detectTestFrameworks(dir: string): TestFramework[];
+/**
+ * Detect CI/CD systems
+ */
+declare function detectCICDSystems(dir: string): CICDSystem[];
+/**
+ * Detect programming languages
+ */
+declare function detectLanguages(dir: string): Language[];
+/**
+ * Determine project type
+ */
+declare function determineProjectType(info: Partial<ProjectInfo>): ProjectType;
+/**
+ * Detect full project information
+ */
+declare function detectProject(dir?: string): ProjectInfo;
+/**
+ * Generate configuration suggestions based on project
+ */
+declare function generateSuggestions(project: ProjectInfo): ConfigSuggestions;
+/**
+ * Get a human-readable project summary
+ */
+declare function getProjectSummary(project: ProjectInfo): string;
+
+declare const COLORS: {
+    primary: ansis.Ansis;
+    secondary: ansis.Ansis;
+    accent: ansis.Ansis;
+    warning: ansis.Ansis;
+    error: ansis.Ansis;
+    success: ansis.Ansis;
+    muted: ansis.Ansis;
+    bold: ansis.Ansis;
+};
+declare function displayBanner(subtitle?: string): void;
+declare function displayBannerWithInfo(subtitle?: string): void;
+declare function renderProgressBar(progress: number, width?: number): string;
+type BoxStyle = 'single' | 'double' | 'rounded' | 'heavy';
+declare function boxify(content: string, style?: BoxStyle, title?: string): string;
+declare function sectionDivider(title?: string, width?: number): string;
+declare const STATUS: {
+    success: (text: string) => string;
+    error: (text: string) => string;
+    warning: (text: string) => string;
+    info: (text: string) => string;
+    pending: (text: string) => string;
+    inProgress: (text: string) => string;
+};
+declare function menuItem(key: string, label: string, description?: string): string;
+
+declare function getMcpConfigPath(): string;
+declare function readMcpConfig(): ClaudeConfiguration | null;
+declare function writeMcpConfig(config: ClaudeConfiguration): void;
+declare function backupMcpConfig(): string | null;
+declare function mergeMcpServers(existing: ClaudeConfiguration | null, newServers: Record<string, McpServerConfig>): ClaudeConfiguration;
+declare function buildMcpServerConfig(baseConfig: McpServerConfig, apiKey?: string, placeholder?: string, envVarName?: string): McpServerConfig;
+declare function fixWindowsMcpConfig(config: ClaudeConfiguration): ClaudeConfiguration;
+declare function addCompletedOnboarding(): void;
+/**
+ * Ensures that an API key is in the approved list and not in the rejected list
+ * @param config - Claude configuration object
+ * @param apiKey - The API key to manage
+ * @returns Updated configuration with API key properly approved
+ */
+declare function ensureApiKeyApproved(config: ClaudeConfiguration, apiKey: string): ClaudeConfiguration;
+/**
+ * Removes an API key from the rejected list
+ * @param config - Claude configuration object
+ * @param apiKey - The API key to remove from rejected list
+ * @returns Updated configuration with API key removed from rejected list
+ */
+declare function removeApiKeyFromRejected(config: ClaudeConfiguration, apiKey: string): ClaudeConfiguration;
+/**
+ * Manages API key approval status by reading config, updating it, and writing it back
+ * @param apiKey - The API key to ensure is approved (e.g., 'sk-ccjk-x-ccr')
+ */
+declare function manageApiKeyApproval(apiKey: string): void;
+/**
+ * Sets the primaryApiKey field in ~/.claude/config.json (VSCode extension config)
+ * This is required for Claude Code 2.0 to properly recognize third-party API configurations
+ * and prevent redirecting to official login page
+ */
+declare function setPrimaryApiKey(): void;
+
+/**
+ * Aider configuration
+ */
+interface AiderConfig {
+    model?: string;
+    editFormat?: 'diff' | 'whole' | 'udiff';
+    apiKey?: string;
+    apiBase?: string;
+    autoCommits?: boolean;
+    dirtyCommits?: boolean;
+    darkMode?: boolean;
+    prettyOutput?: boolean;
+    showDiffs?: boolean;
+    mapTokens?: number;
+    maxChatHistory?: number;
+    cachePrompts?: boolean;
+}
+/**
+ * Check if Aider is installed
+ */
+declare function isAiderInstalled(): Promise<boolean>;
+/**
+ * Get Aider version
+ */
+declare function getAiderVersion(): Promise<string | null>;
+/**
+ * Install Aider
+ */
+declare function installAider(): Promise<{
+    success: boolean;
+    message: string;
+}>;
+/**
+ * Ensure Aider directory exists
+ */
+declare function ensureAiderDir(): void;
+/**
+ * Read Aider configuration
+ */
+declare function readAiderConfig(): AiderConfig;
+/**
+ * Write Aider configuration
+ */
+declare function writeAiderConfig(config: AiderConfig): void;
+/**
+ * Configure Aider API
+ */
+declare function configureAiderApi(apiKey: string, apiBase?: string): void;
+/**
+ * Get Aider model presets
+ */
+declare function getAiderModelPresets(): Record<string, {
+    model: string;
+    description: string;
+}>;
+/**
+ * Run Aider with options
+ */
+declare function runAider(options: {
+    files?: string[];
+    message?: string;
+    model?: string;
+    autoCommit?: boolean;
+}): Promise<{
+    success: boolean;
+    output: string;
+}>;
+
+declare function configureCodexMcp(options?: CodexFullInitOptions): Promise<void>;
+
+/**
+ * Apply platform-specific command transformation for Codex MCP services
+ * Handles Windows cmd /c wrapper for commands like npx, uvx, etc.
+ */
+declare function applyCodexPlatformCommand(config: CodexMcpService): void;
+
+interface CodexProvider {
+    id: string;
+    name: string;
+    baseUrl: string;
+    wireApi: string;
+    tempEnvKey: string;
+    requiresOpenaiAuth: boolean;
+    model?: string;
+}
+interface CodexMcpService {
+    id: string;
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+    startup_timeout_sec?: number;
+    extraFields?: Record<string, any>;
+}
+interface CodexConfigData {
+    model: string | null;
+    modelProvider: string | null;
+    providers: CodexProvider[];
+    mcpServices: CodexMcpService[];
+    managed: boolean;
+    otherConfig?: string[];
+    modelProviderCommented?: boolean;
+}
+interface CodexVersionInfo {
+    installed: boolean;
+    currentVersion: string | null;
+    latestVersion: string | null;
+    needsUpdate: boolean;
+}
+declare function createBackupDirectory(timestamp: string): string;
+declare function backupCodexFiles(): string | null;
+/**
+ * Backup complete Codex directory with all configuration files
+ * This provides the same comprehensive backup functionality as Claude Code
+ *
+ * Note: This is an alias for backupCodexFiles() to maintain API consistency
+ * while following DRY principles (Don't Repeat Yourself)
+ */
+declare function backupCodexComplete(): string | null;
+declare function backupCodexConfig(): string | null;
+declare function backupCodexAgents(): string | null;
+declare function backupCodexPrompts(): string | null;
+declare function getBackupMessage(path: string | null): string;
+/**
+ * Check if the Codex config needs env_key to temp_env_key migration
+ * @returns true if migration is needed, false otherwise
+ */
+declare function needsEnvKeyMigration(): boolean;
+/**
+ * Migrate env_key to temp_env_key in Codex config file
+ * This performs an in-place migration of the TOML config file
+ *
+ * For provider sections that already have temp_env_key, the env_key line is removed.
+ * For provider sections that only have env_key, it is converted to temp_env_key.
+ * This prevents duplicate keys in TOML which would cause parse errors.
+ *
+ * @returns true if migration was performed, false otherwise
+ */
+declare function migrateEnvKeyToTempEnvKey(): boolean;
+/**
+ * Migrate env_key to temp_env_key in TOML content
+ * Handles mixed state where both env_key and temp_env_key may exist in the same section
+ *
+ * @param content - The TOML content to migrate
+ * @returns The migrated content
+ */
+declare function migrateEnvKeyInContent(content: string): string;
+/**
+ * Ensure env_key migration is performed if needed
+ * This should be called before any Codex config modification operation
+ */
+declare function ensureEnvKeyMigration(): void;
+declare function parseCodexConfig(content: string): CodexConfigData;
+declare function readCodexConfig(): CodexConfigData | null;
+declare function renderCodexConfig(data: CodexConfigData): string;
+declare function writeCodexConfig(data: CodexConfigData): void;
+declare function writeAuthFile(newEntries: Record<string, string>): void;
+declare function isCodexInstalled$1(): Promise<boolean>;
+declare function getCodexVersion(): Promise<string | null>;
+declare function checkCodexUpdate(): Promise<CodexVersionInfo>;
+declare function installCodexCli(skipMethodSelection?: boolean): Promise<void>;
+declare function runCodexWorkflowImport(): Promise<void>;
+/**
+ * Run Codex workflow import with language selection (AI output language + system prompt + workflow)
+ * Reuses Claude Code's language selection functionality
+ */
+interface CodexWorkflowLanguageOptions {
+    aiOutputLang?: AiOutputLanguage | string;
+    skipPrompt?: boolean;
+}
+declare function runCodexWorkflowImportWithLanguageSelection(options?: CodexFullInitOptions): Promise<AiOutputLanguage | string>;
+declare function runCodexSystemPromptSelection(skipPrompt?: boolean): Promise<void>;
+declare function runCodexWorkflowSelection(options?: CodexFullInitOptions): Promise<void>;
+declare function configureCodexApi(options?: CodexFullInitOptions): Promise<void>;
+
+interface CodexFullInitOptions extends CodexWorkflowLanguageOptions {
+    workflows?: string[];
+    mcpServices?: string[] | false;
+    apiMode?: 'official' | 'custom' | 'skip';
+    customApiConfig?: {
+        type: 'auth_token' | 'api_key';
+        token?: string;
+        baseUrl?: string;
+        model?: string;
+    };
+}
+declare function runCodexFullInit(options?: CodexFullInitOptions): Promise<AiOutputLanguage | string>;
+declare function runCodexUpdate(force?: boolean, skipPrompt?: boolean): Promise<boolean>;
+declare function runCodexUninstall(): Promise<void>;
+/**
+ * Get current active Codex provider
+ * @returns Current provider ID or null if not set
+ */
+declare function getCurrentCodexProvider(): Promise<string | null>;
+/**
+ * List all available Codex providers
+ * @returns Array of available providers
+ */
+declare function listCodexProviders(): Promise<CodexProvider[]>;
+/**
+ * Switch to a different Codex provider
+ * @param providerId - ID of the provider to switch to
+ * @returns True if switch was successful, false otherwise
+ */
+declare function switchCodexProvider(providerId: string): Promise<boolean>;
+/**
+ * Switch to official login mode (comment out model_provider, set OPENAI_API_KEY to null)
+ * @returns True if switch was successful, false otherwise
+ */
+declare function switchToOfficialLogin$1(): Promise<boolean>;
+/**
+ * Switch to a specific provider (uncomment model_provider, set environment variable in auth.json)
+ * @param providerId - ID of the provider to switch to
+ * @returns True if switch was successful, false otherwise
+ */
+declare function switchToProvider(providerId: string): Promise<boolean>;
+
+interface ConfigManagementMode {
+    mode: 'initial' | 'management';
+    hasProviders: boolean;
+    providerCount: number;
+    currentProvider?: string | null;
+    providers?: CodexProvider[];
+    isUnmanaged?: boolean;
+    error?: string;
+}
+/**
+ * Detect the current configuration state and determine appropriate management mode
+ * @returns Configuration management mode information
+ */
+declare function detectConfigManagementMode(): ConfigManagementMode;
+/**
+ * Determine if configuration should show management options
+ * @param config - The codex configuration data
+ * @returns Whether to show management mode
+ */
+declare function shouldShowManagementMode(config: CodexConfigData | null): boolean;
+/**
+ * Get available management actions based on current configuration
+ * @param config - The codex configuration data
+ * @returns Array of available management actions
+ */
+declare function getAvailableManagementActions(config: CodexConfigData): string[];
+
+/**
+ * Configure incremental management interface for existing Codex configurations
+ */
+declare function configureIncrementalManagement(): Promise<void>;
+
+interface ProviderOperationResult {
+    success: boolean;
+    backupPath?: string;
+    error?: string;
+    addedProvider?: CodexProvider;
+    updatedProvider?: CodexProvider;
+    deletedProviders?: string[];
+    remainingProviders?: CodexProvider[];
+    newDefaultProvider?: string;
+}
+interface ProviderUpdateData {
+    name?: string;
+    baseUrl?: string;
+    wireApi?: 'responses' | 'chat';
+    apiKey?: string;
+    model?: string;
+}
+/**
+ * Add a new provider to existing configuration
+ * @param provider - The new provider to add
+ * @param apiKey - The API key for the provider
+ * @param allowOverwrite - Whether to allow overwriting existing provider
+ * @returns Operation result
+ */
+declare function addProviderToExisting(provider: CodexProvider, apiKey: string, allowOverwrite?: boolean): Promise<ProviderOperationResult>;
+/**
+ * Edit an existing provider configuration
+ * @param providerId - ID of the provider to edit
+ * @param updates - Updates to apply to the provider
+ * @returns Operation result
+ */
+declare function editExistingProvider(providerId: string, updates: ProviderUpdateData): Promise<ProviderOperationResult>;
+/**
+ * Delete selected providers from configuration
+ * @param providerIds - Array of provider IDs to delete
+ * @returns Operation result
+ */
+declare function deleteProviders(providerIds: string[]): Promise<ProviderOperationResult>;
+/**
+ * Validate provider data before operations
+ * @param provider - Provider data to validate
+ * @returns Validation result
+ */
+declare function validateProviderData(provider: Partial<CodexProvider>): {
+    valid: boolean;
+    errors: string[];
+};
+
+type CodexUninstallItem = 'config' | 'auth' | 'system-prompt' | 'workflow' | 'cli-package' | 'api-config' | 'mcp-config' | 'backups';
+interface CodexUninstallResult {
+    success: boolean;
+    removed: string[];
+    removedConfigs: string[];
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Codex Uninstaller - Handles removal of Codex configurations and tools
+ */
+declare class CodexUninstaller {
+    private _lang;
+    private conflictResolution;
+    private readonly CODEX_BACKUP_DIR;
+    constructor(lang?: SupportedLang);
+    /**
+     * Remove config file (config.toml)
+     */
+    removeConfig(): Promise<CodexUninstallResult>;
+    /**
+     * Remove auth file (auth.json)
+     */
+    removeAuth(): Promise<CodexUninstallResult>;
+    /**
+     * Remove system prompt file (AGENTS.md)
+     */
+    removeSystemPrompt(): Promise<CodexUninstallResult>;
+    /**
+     * Remove workflow directory (prompts/)
+     */
+    removeWorkflow(): Promise<CodexUninstallResult>;
+    /**
+     * Uninstall Codex CLI package
+     */
+    uninstallCliPackage(): Promise<CodexUninstallResult>;
+    /**
+     * Remove API configuration from config.toml
+     */
+    removeApiConfig(): Promise<CodexUninstallResult>;
+    /**
+     * Remove backup directory (~/.codex/backup/)
+     */
+    removeBackups(): Promise<CodexUninstallResult>;
+    /**
+     * Remove MCP configuration from config.toml
+     */
+    removeMcpConfig(): Promise<CodexUninstallResult>;
+    /**
+     * Complete uninstall - remove all directories and packages
+     */
+    completeUninstall(): Promise<CodexUninstallResult>;
+    /**
+     * Custom uninstall with conflict resolution
+     */
+    customUninstall(selectedItems: CodexUninstallItem[]): Promise<CodexUninstallResult[]>;
+    /**
+     * Resolve conflicts between uninstall items
+     */
+    private resolveConflicts;
+    /**
+     * Execute uninstall for a specific item
+     */
+    private executeUninstallItem;
+}
+
+/**
+ * Continue model configuration
+ */
+interface ContinueModel {
+    title: string;
+    provider: string;
+    model: string;
+    apiBase?: string;
+    apiKey?: string;
+}
+/**
+ * Continue MCP server configuration
+ */
+interface ContinueMcpServer {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+/**
+ * Continue configuration
+ */
+interface ContinueConfig {
+    models?: ContinueModel[];
+    tabAutocompleteModel?: ContinueModel;
+    embeddingsProvider?: {
+        provider: string;
+        model?: string;
+        apiBase?: string;
+    };
+    reranker?: {
+        name: string;
+        params?: Record<string, any>;
+    };
+    contextProviders?: Array<{
+        name: string;
+        params?: Record<string, any>;
+    }>;
+    slashCommands?: Array<{
+        name: string;
+        description: string;
+    }>;
+    customCommands?: Array<{
+        name: string;
+        description: string;
+        prompt: string;
+    }>;
+    experimental?: {
+        modelContextProtocolServers?: ContinueMcpServer[];
+        promptPath?: string;
+    };
+    allowAnonymousTelemetry?: boolean;
+}
+/**
+ * Ensure Continue directory exists
+ */
+declare function ensureContinueDir(): void;
+/**
+ * Check if Continue is configured
+ */
+declare function isContinueConfigured(): boolean;
+/**
+ * Read Continue configuration
+ */
+declare function readContinueConfig(): ContinueConfig;
+/**
+ * Write Continue configuration
+ */
+declare function writeContinueConfig(config: ContinueConfig): void;
+/**
+ * Add a model to Continue
+ */
+declare function addContinueModel(model: ContinueModel): void;
+/**
+ * Remove a model from Continue
+ */
+declare function removeContinueModel(title: string): boolean;
+/**
+ * Get Continue provider presets
+ */
+declare function getContinueProviderPresets(): Record<string, ContinueModel>;
+/**
+ * Configure Continue API key
+ */
+declare function configureContinueApi(provider: string, apiKey: string, apiBase?: string): void;
+/**
+ * Add MCP server to Continue
+ */
+declare function addContinueMcpServer(_name: string, server: ContinueMcpServer): void;
+/**
+ * Add custom command to Continue
+ */
+declare function addContinueCustomCommand(name: string, description: string, prompt: string): void;
+/**
+ * Enable context provider
+ */
+declare function enableContinueContextProvider(name: string, params?: Record<string, any>): void;
+/**
+ * Sync CCJK skills to Continue custom commands
+ */
+declare function syncSkillsToContinue(skills: Array<{
+    id: string;
+    name: string;
+    description: string;
+    template: string;
+}>): void;
+
+/**
+ * Tool installation status
+ */
+interface ToolStatus {
+    tool: CodeToolType;
+    installed: boolean;
+    version?: string;
+    configExists: boolean;
+    configPath: string;
+    lastChecked: Date;
+}
+/**
+ * Tool installation result
+ */
+interface ToolInstallResult {
+    tool: CodeToolType;
+    success: boolean;
+    message: string;
+    version?: string;
+}
+/**
+ * Get tool config path
+ */
+declare function getToolConfigPath(tool: CodeToolType): string;
+/**
+ * Get tool directory
+ */
+declare function getToolDir(tool: CodeToolType): string;
+/**
+ * Check if a tool is installed
+ */
+declare function isToolInstalled(tool: CodeToolType): Promise<boolean>;
+/**
+ * Get tool version
+ */
+declare function getToolVersion(tool: CodeToolType): Promise<string | null>;
+/**
+ * Get status of a tool
+ */
+declare function getToolStatus(tool: CodeToolType): Promise<ToolStatus>;
+/**
+ * Get status of all tools
+ */
+declare function getAllToolsStatus(): Promise<ToolStatus[]>;
+/**
+ * Get installed tools
+ */
+declare function getInstalledTools(): Promise<CodeToolType[]>;
+/**
+ * Install a tool
+ */
+declare function installTool(tool: CodeToolType): Promise<ToolInstallResult>;
+/**
+ * Get tool info
+ */
+declare function getToolInfo(tool: CodeToolType): {
+    name: string;
+    description: string;
+    website: string;
+    installCmd: string;
+    configFormat: "json" | "toml" | "yaml";
+    category: "cli" | "extension" | "editor";
+};
+/**
+ * Get all tools info
+ */
+declare function getAllToolsInfo(): Record<"claude-code" | "codex" | "aider" | "continue" | "cline" | "cursor", {
+    name: string;
+    description: string;
+    website: string;
+    installCmd: string;
+    configFormat: "json" | "toml" | "yaml";
+    category: "cli" | "extension" | "editor";
+}>;
+/**
+ * Get tools by category
+ */
+declare function getToolsByCategory(category: 'cli' | 'extension' | 'editor'): CodeToolType[];
+/**
+ * Format tool status for display
+ */
+declare function formatToolStatus(status: ToolStatus): string;
+/**
+ * Get recommended tools based on project type
+ */
+declare function getRecommendedTools(projectType: string): CodeToolType[];
+
+/**
+ * API configuration for Claude Code
+ */
+interface ApiConfig {
+    url: string;
+    key: string;
+    authType?: 'auth_token' | 'api_key';
+}
+/**
+ * Installation method types for code tools
+ */
+type InstallMethod = 'npm' | 'homebrew' | 'curl' | 'powershell' | 'cmd';
+
+declare function ensureClaudeDir(): void;
+declare function backupExistingConfig(): string | null;
+declare function copyConfigFiles(onlyMd?: boolean): void;
+declare function configureApi(apiConfig: ApiConfig | null): ApiConfig | null;
+declare function mergeConfigs(sourceFile: string, targetFile: string): void;
+/**
+ * Update custom model configuration using environment variables
+ * @param primaryModel - Primary model name for general tasks
+ * @param haikuModel - Default Haiku model (optional)
+ * @param sonnetModel - Default Sonnet model (optional)
+ * @param opusModel - Default Opus model (optional)
+ */
+declare function updateCustomModel(primaryModel?: string, haikuModel?: string, sonnetModel?: string, opusModel?: string): void;
+/**
+ * Update the default model configuration in settings.json
+ * @param model - The model type to set: opus, sonnet, sonnet[1m], default, or custom
+ * Note: 'custom' model type is handled differently - it should use environment variables instead
+ */
+declare function updateDefaultModel(model: 'opus' | 'sonnet' | 'sonnet[1m]' | 'default' | 'custom'): void;
+/**
+ * Merge settings.json intelligently
+ * Preserves user's environment variables and custom configurations
+ */
+declare function mergeSettingsFile(templatePath: string, targetPath: string): void;
+/**
+ * Get existing model configuration from settings.json
+ */
+declare function getExistingModelConfig(): 'opus' | 'sonnet' | 'sonnet[1m]' | 'default' | 'custom' | null;
+/**
+ * Get existing API configuration from settings.json
+ */
+declare function getExistingApiConfig(): ApiConfig | null;
+declare function applyAiLanguageDirective(aiOutputLang: AiOutputLanguage | string): void;
+/**
+ * Switch to official login mode - remove all third-party API configurations
+ * Removes: ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN, ANTHROPIC_API_KEY from settings.json
+ * Removes: primaryApiKey from ~/.claude/config.json
+ */
+declare function switchToOfficialLogin(): boolean;
+/**
+ * Prompt user for API configuration action when existing config is found
+ * Returns the user's choice for how to handle existing configuration
+ */
+declare function promptApiConfigurationAction(): Promise<'modify-partial' | 'modify-all' | 'keep-existing' | null>;
+
+/**
+ * Config file location
+ */
+interface ConfigLocation {
+    path: string;
+    type: 'global' | 'legacy' | 'project' | 'custom';
+    exists: boolean;
+    size?: number;
+    modifiedAt?: Date;
+    content?: any;
+}
+/**
+ * Config difference
+ */
+interface ConfigDiff {
+    key: string;
+    files: string[];
+    values: Record<string, any>;
+    conflicting: boolean;
+}
+/**
+ * Consolidated config result
+ */
+interface ConsolidatedConfig {
+    success: boolean;
+    config: any;
+    mergedFrom: string[];
+    conflicts: ConfigDiff[];
+    backupPaths: string[];
+}
+/**
+ * Detect all config files
+ */
+declare function detectAllConfigs(projectDir?: string): ConfigLocation[];
+/**
+ * Compare configs and find differences
+ */
+declare function compareConfigs(configs: ConfigLocation[]): ConfigDiff[];
+/**
+ * Consolidate configs into a single file
+ */
+declare function consolidateConfigs(configs: ConfigLocation[], strategy?: 'merge' | 'newest' | 'interactive'): ConsolidatedConfig;
+/**
+ * Write consolidated config to primary location
+ */
+declare function writeConsolidatedConfig(config: any): boolean;
+/**
+ * Remove redundant config files (after consolidation)
+ */
+declare function removeRedundantConfigs(configs: ConfigLocation[], keepPath?: string): string[];
+/**
+ * Display config scan results
+ */
+declare function displayConfigScan(configs: ConfigLocation[]): void;
+
+/**
+ * Check result
+ */
+interface CheckResult {
+    name: string;
+    status: 'pass' | 'warn' | 'fail' | 'info';
+    message: string;
+    details?: string;
+    fixable?: boolean;
+    fixCommand?: string;
+}
+/**
+ * Health report
+ */
+interface HealthReport {
+    timestamp: Date;
+    score: number;
+    checks: CheckResult[];
+    recommendations: string[];
+}
+/**
+ * Run full health check
+ */
+declare function runHealthCheck(): Promise<HealthReport>;
+/**
+ * Display health report
+ */
+declare function displayHealthReport(report: HealthReport): void;
+/**
+ * Run doctor command
+ */
+declare function runDoctor(fix?: boolean): Promise<void>;
+
+declare function isClaudeCodeInstalled(): Promise<boolean>;
+/**
+ * Install Claude Code with method selection support
+ * @param skipMethodSelection - If true, use default npm installation
+ */
+declare function installClaudeCode(skipMethodSelection?: boolean): Promise<void>;
+/**
+ * Check if Codex is installed
+ */
+declare function isCodexInstalled(): Promise<boolean>;
+/**
+ * Install Codex with method selection support
+ * @param skipMethodSelection - If true, use default npm installation
+ */
+declare function installCodex(skipMethodSelection?: boolean): Promise<void>;
+/**
+ * Check if local Claude Code installation exists
+ */
+declare function isLocalClaudeCodeInstalled(): Promise<boolean>;
+/**
+ * Get installation status for both global and local Claude Code
+ */
+interface InstallationStatus {
+    hasGlobal: boolean;
+    hasLocal: boolean;
+    localPath: string;
+}
+declare function getInstallationStatus(): Promise<InstallationStatus>;
+/**
+ * Remove local Claude Code installation
+ */
+declare function removeLocalClaudeCode(): Promise<void>;
+/**
+ * Uninstall code tool based on install method
+ * @param codeType - Type of code tool to uninstall
+ * @returns true if uninstalled successfully
+ */
+declare function uninstallCodeTool(codeType: CodeType): Promise<boolean>;
+/**
+ * Set installMethod in both ~/.claude.json and ccjk-config
+ * This ensures Claude Code knows it was installed via npm for proper auto-updates
+ */
+declare function setInstallMethod(method: InstallMethod, codeType?: CodeType): Promise<void>;
+/**
+ * Detect installed version of a code tool
+ * Returns version string or null if not installed
+ */
+declare function detectInstalledVersion(codeType: CodeType): Promise<string | null>;
+/**
+ * Select installation method interactively
+ */
+declare function selectInstallMethod(codeType: CodeType, excludeMethods?: InstallMethod[]): Promise<InstallMethod | null>;
+/**
+ * Execute installation using specified method
+ */
+declare function executeInstallMethod(method: InstallMethod, codeType: CodeType): Promise<boolean>;
+/**
+ * Handle installation failure with retry options
+ */
+declare function handleInstallFailure(codeType: CodeType, failedMethods: InstallMethod[]): Promise<boolean>;
+/**
+ * Installation verification result
+ */
+interface VerificationResult {
+    success: boolean;
+    commandPath: string | null;
+    version: string | null;
+    needsSymlink: boolean;
+    symlinkCreated: boolean;
+    error?: string;
+}
+/**
+ * Verify installation by checking command availability and version
+ * If command is not in PATH but found in Homebrew paths, attempt to create symlink
+ */
+declare function verifyInstallation(codeType: CodeType): Promise<VerificationResult>;
+/**
+ * Symlink creation result
+ */
+interface SymlinkResult {
+    success: boolean;
+    symlinkPath: string | null;
+    error?: string;
+}
+/**
+ * Create symlink in Homebrew bin directory for commands installed via npm
+ * This handles the case where npm global packages are installed to
+ * /opt/homebrew/Cellar/node/{version}/bin/ but that path is not in the user's PATH
+ */
+declare function createHomebrewSymlink(command: string, sourcePath: string): Promise<SymlinkResult>;
+/**
+ * Display verification result to user with appropriate messages
+ */
+declare function displayVerificationResult(result: VerificationResult, codeType: CodeType): void;
+
+/**
+ * Knowledge base entry
+ */
+interface KnowledgeEntry {
+    id: string;
+    type: 'claude-md' | 'agent' | 'skill' | 'workflow' | 'project-info';
+    name: string;
+    path: string;
+    content: string;
+    hash: string;
+    createdAt: string;
+    updatedAt: string;
+    projectRoot?: string;
+}
+/**
+ * Knowledge base
+ */
+interface KnowledgeBase {
+    version: string;
+    lastSync: string;
+    entries: KnowledgeEntry[];
+    projectContexts: ProjectContext[];
+}
+/**
+ * Project context for knowledge
+ */
+interface ProjectContext {
+    rootDir: string;
+    name: string;
+    type: string;
+    frameworks: string[];
+    lastScanned: string;
+    claudeMdHash?: string;
+    agentsCount: number;
+    skillsCount: number;
+}
+/**
+ * Onboarding result
+ */
+interface OnboardingResult {
+    success: boolean;
+    projectDetected: boolean;
+    claudeMdFound: boolean;
+    claudeMdUpdated: boolean;
+    agentsFound: number;
+    skillsFound: number;
+    knowledgeEntriesCreated: number;
+    recommendations: string[];
+}
+/**
+ * Load knowledge base
+ */
+declare function loadKnowledgeBase(): KnowledgeBase;
+/**
+ * Save knowledge base
+ */
+declare function saveKnowledgeBase(kb: KnowledgeBase): void;
+/**
+ * Run onboarding process
+ */
+declare function runOnboarding(projectDir?: string): Promise<OnboardingResult>;
+/**
+ * Quick sync - update knowledge base without prompts
+ */
+declare function quickSync(projectDir?: string): Promise<void>;
+/**
+ * Get knowledge for current project
+ */
+declare function getProjectKnowledge(projectDir?: string): KnowledgeEntry[];
+/**
+ * Export knowledge for a project
+ */
+declare function exportProjectKnowledge(projectDir?: string): string;
+
+/**
+ * Clean up and deduplicate permissions array
+ * Removes invalid and redundant permissions based on template
+ */
+/**
+ * Clean up permissions array by removing invalid and redundant entries
+ * @param templatePermissions - Permissions from template (source of truth)
+ * @param userPermissions - User's existing permissions
+ * @returns Cleaned permissions array
+ */
+declare function cleanupPermissions(templatePermissions: string[], userPermissions: string[]): string[];
+/**
+ * Merge and clean permissions arrays
+ * Combines template and user permissions while removing invalid/redundant entries
+ * @param templatePermissions - Permissions from template
+ * @param userPermissions - User's existing permissions
+ * @returns Merged and cleaned permissions array
+ */
+declare function mergeAndCleanPermissions(templatePermissions: string[] | undefined, userPermissions: string[] | undefined): string[];
+
+/**
+ * Permission types
+ */
+type PermissionType = 'file-read' | 'file-write' | 'file-delete' | 'git-operations' | 'npm-commands' | 'node-execution' | 'system-commands' | 'network-access' | 'mcp-server';
+/**
+ * Permission set
+ */
+interface PermissionSet {
+    allowed: PermissionType[];
+    denied: PermissionType[];
+    trustedDirectories: string[];
+    autoApprovePatterns: string[];
+}
+/**
+ * Permission template
+ */
+interface PermissionTemplate {
+    id: string;
+    name: string;
+    description: string;
+    permissions: PermissionSet;
+}
+/**
+ * Predefined permission templates
+ */
+declare const PERMISSION_TEMPLATES: PermissionTemplate[];
+/**
+ * Read current permissions
+ */
+declare function readPermissions(): PermissionSet;
+/**
+ * Write permissions
+ */
+declare function writePermissions(permissions: PermissionSet): boolean;
+/**
+ * Apply a permission template
+ */
+declare function applyTemplate(templateId: string): boolean;
+/**
+ * Trust a directory
+ */
+declare function trustDirectory(path: string): boolean;
+/**
+ * Untrust a directory
+ */
+declare function untrustDirectory(path: string): boolean;
+/**
+ * Check if a permission is allowed
+ */
+declare function isPermissionAllowed(permission: PermissionType): boolean;
+/**
+ * Check if a directory is trusted
+ */
+declare function isDirectoryTrusted(path: string): boolean;
+/**
+ * Add auto-approve pattern
+ */
+declare function addAutoApprovePattern(pattern: string): boolean;
+/**
+ * Remove auto-approve pattern
+ */
+declare function removeAutoApprovePattern(pattern: string): boolean;
+/**
+ * Reset permissions to default
+ */
+declare function resetPermissions(): boolean;
+/**
+ * Export permissions to JSON
+ */
+declare function exportPermissions(): string;
+/**
+ * Import permissions from JSON
+ */
+declare function importPermissions(json: string): boolean;
+/**
+ * Get current template ID (if matching)
+ */
+declare function getCurrentTemplateId(): string | null;
+/**
+ * Display permissions dashboard
+ */
+declare function displayPermissions(): void;
+
+declare function importRecommendedEnv(): Promise<void>;
+declare function importRecommendedPermissions(): Promise<void>;
+declare function openSettingsJson(): Promise<void>;
+
+/**
+ * Menu item definition
+ */
+interface MenuItem {
+    /** Single key shortcut */
+    key: string;
+    /** Display label */
+    label: string;
+    /** Optional description */
+    description?: string;
+    /** Icon/emoji */
+    icon?: string;
+    /** Action to execute */
+    action: () => Promise<MenuResult>;
+    /** Condition for visibility */
+    visible?: () => boolean;
+    /** Whether this is a highlighted/recommended option */
+    highlight?: boolean;
+    /** Whether this item is disabled */
+    disabled?: boolean;
+}
+/**
+ * Menu section
+ */
+interface MenuSection {
+    /** Section title */
+    title: string;
+    /** Items in this section */
+    items: MenuItem[];
+    /** Section icon */
+    icon?: string;
+}
+/**
+ * Menu result
+ */
+interface MenuResult {
+    /** Action taken */
+    action: 'continue' | 'back' | 'exit' | 'switch';
+    /** Optional data */
+    data?: any;
+}
+/**
+ * Menu builder options
+ */
+interface MenuBuilderOptions {
+    /** Menu title */
+    title: string;
+    /** Menu subtitle */
+    subtitle?: string;
+    /** Show back option */
+    showBack?: boolean;
+    /** Show exit option */
+    showExit?: boolean;
+    /** Breadcrumb path */
+    breadcrumb?: string[];
+    /** Box style */
+    boxStyle?: 'single' | 'double' | 'rounded' | 'heavy';
+}
+/**
+ * Menu builder for creating interactive menus
+ */
+declare class MenuBuilder {
+    private sections;
+    private options;
+    constructor(options: MenuBuilderOptions);
+    /**
+     * Add a section to the menu
+     */
+    addSection(title: string, icon?: string): MenuBuilder;
+    /**
+     * Add an item to the current section
+     */
+    addItem(item: MenuItem): MenuBuilder;
+    /**
+     * Add a separator
+     */
+    addSeparator(): MenuBuilder;
+    /**
+     * Render the menu to string
+     */
+    render(): string;
+    /**
+     * Display menu and handle input
+     */
+    show(): Promise<MenuResult>;
+    /**
+     * Run menu loop until exit or back
+     */
+    loop(): Promise<MenuResult>;
+}
+/**
+ * Quick menu helper
+ */
+declare function showQuickMenu(title: string, items: Array<{
+    key: string;
+    label: string;
+    action: () => Promise<void>;
+}>): Promise<void>;
+/**
+ * Confirmation prompt helper
+ */
+declare function confirm(message: string, defaultValue?: boolean): Promise<boolean>;
+/**
+ * Display status message
+ */
+declare function showStatus(type: keyof typeof STATUS, message: string): void;
+
+/**
+ * Version information
+ */
+interface VersionInfo {
+    current: string;
+    latest: string;
+    updateAvailable: boolean;
+    releaseUrl?: string;
+}
+/**
+ * Upgrade result
+ */
+interface UpgradeResult {
+    success: boolean;
+    previousVersion?: string;
+    newVersion?: string;
+    error?: string;
+}
+/**
+ * Plugin version info
+ */
+interface PluginVersionInfo {
+    name: string;
+    current: string;
+    latest?: string;
+    updateAvailable: boolean;
+}
+/**
+ * Check Claude Code version
+ */
+declare function checkClaudeCodeVersion(): Promise<VersionInfo>;
+/**
+ * Check CCJK version
+ */
+declare function checkCcjkVersion(): Promise<VersionInfo>;
+/**
+ * Check all plugin versions
+ */
+declare function checkPluginVersions(): Promise<PluginVersionInfo[]>;
+/**
+ * Upgrade Claude Code
+ */
+declare function upgradeClaudeCode(): Promise<UpgradeResult>;
+/**
+ * Upgrade CCJK
+ */
+declare function upgradeCcjk(): Promise<UpgradeResult>;
+/**
+ * Upgrade a specific plugin
+ */
+declare function upgradePlugin(_pluginId: string): Promise<UpgradeResult>;
+/**
+ * Upgrade all plugins
+ */
+declare function upgradeAllPlugins(): Promise<UpgradeResult[]>;
+/**
+ * Check all versions and display summary
+ */
+declare function checkAllVersions(): Promise<void>;
+/**
+ * Upgrade everything
+ */
+declare function upgradeAll(): Promise<void>;
+
+export { AIDER_CONFIG_FILE, AIDER_DIR, AIDER_ENV_FILE, AI_OUTPUT_LANGUAGES, API_DEFAULT_URL, API_ENV_KEY, CCJK_CONFIG_DIR, CCJK_CONFIG_FILE, CCJK_GROUPS_DIR, CCJK_PLUGINS_DIR, CCJK_SKILLS_DIR, CLAUDE_DIR, CLAUDE_MD_FILE, CLAUDE_VSC_CONFIG_FILE, CLINE_CONFIG_FILE, CLINE_DIR, CODEX_AGENTS_FILE, CODEX_AUTH_FILE, CODEX_CONFIG_FILE, CODEX_DIR, CODEX_PROMPTS_DIR, CODE_TOOL_ALIASES, CODE_TOOL_BANNERS, CODE_TOOL_INFO, CODE_TOOL_TYPES, COLORS, CONTINUE_CONFIG_FILE, CONTINUE_DIR, CURSOR_CONFIG_FILE, CURSOR_DIR, ClAUDE_CONFIG_FILE, CodexUninstaller, DEFAULT_CODE_TOOL_TYPE, LANG_LABELS, LEGACY_ZCF_CONFIG_DIR, LEGACY_ZCF_CONFIG_FILE, LEGACY_ZCF_CONFIG_FILES, MenuBuilder, PERMISSION_TEMPLATES, SETTINGS_FILE, STATUS, SUPPORTED_LANGS, ZCF_CONFIG_DIR, ZCF_CONFIG_FILE, addAutoApprovePattern, addCompletedOnboarding, addContinueCustomCommand, addContinueMcpServer, addContinueModel, addGroup, addProviderToExisting, addSkill, applyAiLanguageDirective, applyCodexPlatformCommand, applyTemplate, backupCodexAgents, backupCodexComplete, backupCodexConfig, backupCodexFiles, backupCodexPrompts, backupExistingConfig, backupMcpConfig, boxify, buildMcpServerConfig, checkAllVersions, checkCcjkVersion, checkClaudeCodeVersion, checkCodexUpdate, checkPluginVersions, cleanupPermissions, switchToOfficialLogin$1 as codexSwitchToOfficialLogin, commandExists, compareConfigs, configureAiderApi, configureApi, configureCodexApi, configureCodexMcp, configureContinueApi, configureIncrementalManagement, confirm, consolidateConfigs, copyConfigFiles, createBackupDirectory, createBatchSkills, createHomebrewSymlink, deleteProviders, detectAllConfigs, detectBuildTools, detectCICDSystems, detectConfigManagementMode, detectFrameworks, detectInstalledVersion, detectLanguages, detectPackageManager, detectProject, detectTestFrameworks, determineProjectType, disableGroup, disablePlugin, discoverPlugins, displayBanner, displayBannerWithInfo, displayConfigScan, displayCurrentStatus, displayHealthReport, displayPermissions, displayVerificationResult, editExistingProvider, enableContinueContextProvider, enableGroup, enablePlugin, ensureAiderDir, ensureApiKeyApproved, ensureClaudeDir, ensureContinueDir, ensureEnvKeyMigration, ensureGroupsDir, ensurePluginsDir, ensureSkillsDir, executeInstallMethod, exportGroups, exportPermissions, exportProjectKnowledge, exportSkills, fixWindowsMcpConfig, formatToolStatus, generateSuggestions, getAiOutputLanguageLabel, getAiderModelPresets, getAiderVersion, getAllGroups, getAllSkills, getAllToolsInfo, getAllToolsStatus, getAvailableManagementActions, getBackupMessage, getBatchCategories, getCodexVersion, getContinueProviderPresets, getCurrentCodexProvider, getCurrentTemplateId, getEnabledAgents, getEnabledSkillIds, getExistingApiConfig, getExistingModelConfig, getGroup, getRegistry as getGroupRegistry, getInstallationStatus, getInstalledTools, getLoadedPlugins, getMcpConfigPath, getPlatform, getPluginAgents, getPluginInfo, getPluginMcpServices, getPluginOutputStyles, getPluginSkills, getPluginWorkflows, getProjectKnowledge, getProjectSummary, getRecommendedTools, getSkill, getRegistry$1 as getSkillRegistry, getToolConfigPath, getToolDir, getToolInfo, getToolStatus, getToolVersion, getToolsByCategory, handleInstallFailure, importGroups, importPermissions, importRecommendedEnv, importRecommendedPermissions, importSkills, init, initializePlugins, installAider, installClaudeCode, installCodex, installCodexCli, installTool, isAiderInstalled, isClaudeCodeInstalled, isCodeToolType, isCodexInstalled$1 as isCodexCliInstalled, isCodexInstalled, isContinueConfigured, isDirectoryTrusted, isGroupEnabled, isLocalClaudeCodeInstalled, isPermissionAllowed, isToolInstalled, listCodexProviders, listPlugins, loadKnowledgeBase, loadPlugin, manageApiKeyApproval, menuItem, mergeAndCleanPermissions, mergeConfigs, mergeMcpServers, mergeSettingsFile, migrateEnvKeyInContent, migrateEnvKeyToTempEnvKey, needsEnvKeyMigration, openSettingsJson, parseCodexConfig, promptApiConfigurationAction, quickSync, readAiderConfig, readCodexConfig, readContinueConfig, readMcpConfig, readPermissions, readPluginConfig, refreshRegistry as refreshGroupRegistry, refreshRegistry$1 as refreshSkillRegistry, removeApiKeyFromRejected, removeAutoApprovePattern, removeContinueModel, removeGroup, removeLocalClaudeCode, removeRedundantConfigs, removeSkill, renderCodexConfig, renderProgressBar, resetPermissions, resolveCodeToolType, runAider, runCodexFullInit, runCodexSystemPromptSelection, runCodexUninstall, runCodexUpdate, runCodexWorkflowImport, runCodexWorkflowImportWithLanguageSelection, runCodexWorkflowSelection, runConfigWizard, runDoctor, runHealthCheck, runOnboarding, saveKnowledgeBase, searchGroups, searchSkills, sectionDivider, selectInstallMethod, setInstallMethod, setPrimaryApiKey, setSkillEnabled, shouldShowManagementMode, showQuickMenu, showStatus, switchCodexProvider, switchToOfficialLogin, switchToProvider, syncSkillsToContinue, trustDirectory, uninstallCodeTool, unloadPlugin, untrustDirectory, updateCustomModel, updateDefaultModel, upgradeAll, upgradeAllPlugins, upgradeCcjk, upgradeClaudeCode, upgradePlugin, validateProviderData, verifyInstallation, writeAiderConfig, writeAuthFile, writeCodexConfig, writeConsolidatedConfig, writeContinueConfig, writeMcpConfig, writePermissions, writePluginConfig };
+export type { AgentDefinition, AgentExtension, AgentTemplate, AiOutputLanguage, AiderConfig, ApiConfig, AuditCycle, AuditCycleStatus, AuditReport, BatchSkillOptions, BatchSkillTemplate, BoxStyle, BuildTool, CICDSystem, CcjkPlugin, CcjkSkill, CheckResult, ClaudeConfiguration, CodeToolType, CodexConfigData, CodexFullInitOptions, CodexProvider, CodexUninstallItem, CodexUninstallResult, CodexVersionInfo, CommandExtension, ConfigDiff, ConfigLocation, ConfigManagementMode, ConfigSuggestions, ConsolidatedConfig, ContinueConfig, ContinueMcpServer, ContinueModel, EvaluatedIssue, ExecutionPlan, FileChange, FixDecision, FixPlan, FixResult, Framework, GeneratedFix, GroupCategory, GroupExport, GroupInstallResult, GroupRegistry, GroupSearchOptions, HealthReport, InstallationStatus, Issue, KnowledgeBase, KnowledgeEntry, Language, LanguageGroupId, LoadedPlugin, McpServerConfig, McpService, McpServiceExtension, MenuBuilderOptions, MenuItem, MenuResult, MenuSection, NewIssue, OnboardingResult, OutputStyleExtension, PackageManager, PermissionSet, PermissionTemplate, PermissionType, PluginConfig, PluginContext, PluginDiscoveryResult, PluginInfo, PluginLogger, PluginMetadata, PluginStorage, PluginVersionInfo, PredefinedGroupId, ProjectContext, ProjectInfo, ProjectType, ProviderOperationResult, ProviderUpdateData, Regression, ScanResult, ScanStrategy, ScanTarget, ShenChaConfig, SiteTypeGroupId, SkillCategory, SkillExport, SkillInstallResult, SkillRegistry, SkillSearchOptions, SpecialtyGroupId, SubagentGroup, SupportedLang, TestFramework, ToolInstallResult, ToolStatus, UpgradeResult, VerificationResult, VerifyResult, VersionInfo, WorkflowExtension };