@omnidev-ai/core 0.3.0 → 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,889 @@
+import { buildCommand, buildRouteMap } from "@stricli/core";
+
+//#region src/types/capability-export.d.ts
+
+/**
+ * Capability Export Types
+ *
+ * These types define the structure that capabilities use to export their features.
+ * Capabilities should import these types from @omnidev-ai/core and use them in their index.ts.
+ */
+/**
+ * File content structure for programmatic file creation
+ */
+interface FileContent {
+  /** File name (relative path within capability) */
+  name: string;
+  /** File content */
+  content: string;
+}
+/**
+ * Documentation export structure
+ */
+interface DocExport {
+  /** Document title */
+  title: string;
+  /** Markdown content */
+  content: string;
+}
+/**
+ * Skill export structure
+ */
+interface SkillExport {
+  /** SKILL.md content (markdown with YAML frontmatter) */
+  skillMd: string;
+  /** Optional: Reference files to create (files the skill needs access to) */
+  references?: FileContent[];
+  /** Optional: Additional files to create (templates, examples, etc.) */
+  additionalFiles?: FileContent[];
+}
+/**
+ * Subagent export structure
+ *
+ * Defines a subagent that Claude can delegate tasks to.
+ * Uses YAML frontmatter in markdown format for configuration.
+ *
+ * @example
+ * ```typescript
+ * const codeReviewer: SubagentExport = {
+ *   subagentMd: `---
+ * name: code-reviewer
+ * description: Reviews code for quality and best practices
+ * tools: Read, Glob, Grep
+ * model: sonnet
+ * ---
+ *
+ * You are a code reviewer. When invoked, analyze the code and provide
+ * specific, actionable feedback on quality, security, and best practices.`
+ * };
+ * ```
+ */
+interface SubagentExport {
+  /** SUBAGENT.md content (markdown with YAML frontmatter) */
+  subagentMd: string;
+}
+/**
+ * Slash command export structure
+ *
+ * Defines a slash command that can be invoked in Claude Code.
+ * Uses YAML frontmatter in markdown format for configuration.
+ *
+ * @example
+ * ```typescript
+ * const fixIssue: CommandExport = {
+ *   commandMd: `---
+ * name: fix-issue
+ * description: Fix a GitHub issue following coding standards
+ * allowed-tools: Bash(git add:*), Bash(git commit:*)
+ * ---
+ *
+ * Fix issue #$ARGUMENTS following our coding standards.
+ *
+ * 1. Read the issue details
+ * 2. Implement the fix
+ * 3. Write tests
+ * 4. Create a commit`
+ * };
+ * ```
+ */
+interface CommandExport {
+  /** COMMAND.md content (markdown with YAML frontmatter) */
+  commandMd: string;
+}
+/**
+ * Complete capability export structure
+ *
+ * Capabilities export this as their default export from index.ts.
+ * All content fields are OPTIONAL and PROGRAMMATIC.
+ * Capabilities can also provide content via static files in their directory.
+ * Both approaches are supported and will be merged during sync.
+ *
+ * @example
+ * ```typescript
+ * // Static files approach - just export CLI commands
+ * export default {
+ *   cliCommands: { mycap: myRoutes },
+ *   gitignore: ["mycap/"],
+ *   sync
+ * } satisfies CapabilityExport;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Programmatic approach - generate content dynamically
+ * export default {
+ *   cliCommands: { mycap: myRoutes },
+ *   docs: [{ title: "Guide", content: "# Guide\n..." }],
+ *   rules: ["# Rule content..."],
+ *   skills: [{ skillMd: "...", references: [...] }],
+ *   gitignore: ["mycap/"],
+ *   sync
+ * } satisfies CapabilityExport;
+ * ```
+ */
+interface CapabilityExport {
+  /** CLI commands provided by this capability */
+  cliCommands?: Record<string, unknown>;
+  /** Documentation (programmatic - optional, can also use docs/ directory) */
+  docs?: DocExport[];
+  /** Rules (programmatic - optional, can also use rules/ directory) */
+  rules?: string[];
+  /** Skills (programmatic - optional, can also use skills/ directory) */
+  skills?: SkillExport[];
+  /** Subagents (programmatic - optional, can also use subagents/ directory) */
+  subagents?: SubagentExport[];
+  /** Commands (programmatic - optional, can also use commands/ directory) */
+  commands?: CommandExport[];
+  /** Gitignore patterns */
+  gitignore?: string[];
+  /** Custom sync hook function */
+  sync?: () => Promise<void>;
+  /** Additional exports for extensibility */
+  [key: string]: unknown;
+}
+//#endregion
+//#region src/types/index.d.ts
+interface CapabilityMetadata {
+  id: string;
+  name: string;
+  version: string;
+  description: string;
+  /** Optional author information */
+  author?: {
+    name?: string;
+    email?: string;
+  };
+  /** Optional metadata about the capability author and source */
+  metadata?: {
+    author?: string;
+    repository?: string;
+    license?: string;
+    /** True if this capability was auto-generated by wrapping a skills repo */
+    wrapped?: boolean;
+    /** For wrapped capabilities: the full commit hash */
+    commit?: string;
+    /** True if this capability was auto-generated from omni.toml [mcps] section */
+    generated_from_omni_toml?: boolean;
+  };
+}
+interface CapabilityExports {
+  module?: string;
+  gitignore?: string[];
+}
+interface EnvDeclaration {
+  required?: boolean;
+  secret?: boolean;
+  default?: string;
+}
+interface SyncConfig {
+  on_sync?: string;
+}
+interface CliConfig {
+  commands?: string[];
+}
+interface CapabilityConfig {
+  capability: CapabilityMetadata;
+  exports?: CapabilityExports;
+  env?: Record<string, EnvDeclaration | Record<string, never>>;
+  mcp?: McpConfig;
+  sync?: SyncConfig;
+  cli?: CliConfig;
+}
+type McpTransport = "stdio" | "sse" | "http";
+interface McpToolSchema {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+interface McpConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+  transport?: McpTransport;
+  tools?: McpToolSchema[];
+}
+interface Skill {
+  name: string;
+  description: string;
+  instructions: string;
+  capabilityId: string;
+}
+interface Rule {
+  name: string;
+  content: string;
+  capabilityId: string;
+}
+interface Doc {
+  name: string;
+  content: string;
+  capabilityId: string;
+}
+type SubagentModel = "sonnet" | "opus" | "haiku" | "inherit";
+type SubagentPermissionMode = "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "plan";
+interface SubagentHookConfig {
+  matcher?: string;
+  hooks: {
+    type: "command";
+    command: string;
+  }[];
+}
+interface SubagentHooks {
+  PreToolUse?: SubagentHookConfig[];
+  PostToolUse?: SubagentHookConfig[];
+  Stop?: SubagentHookConfig[];
+}
+interface Subagent {
+  /** Unique identifier using lowercase letters and hyphens */
+  name: string;
+  /** When Claude should delegate to this subagent */
+  description: string;
+  /** System prompt that guides the subagent's behavior */
+  systemPrompt: string;
+  /** Tools the subagent can use (inherits all if omitted) */
+  tools?: string[];
+  /** Tools to deny (removed from inherited or specified list) */
+  disallowedTools?: string[];
+  /** Model to use: sonnet, opus, haiku, or inherit */
+  model?: SubagentModel;
+  /** Permission mode for the subagent */
+  permissionMode?: SubagentPermissionMode;
+  /** Skills to load into the subagent's context at startup */
+  skills?: string[];
+  /** Lifecycle hooks scoped to this subagent */
+  hooks?: SubagentHooks;
+  /** Capability that provides this subagent */
+  capabilityId: string;
+}
+interface Command {
+  /** Command name (used as /command-name) */
+  name: string;
+  /** Brief description of what this command does */
+  description: string;
+  /** Optional allowed tools specification (e.g., "Bash(git add:*), Bash(git status:*)") */
+  allowedTools?: string;
+  /** Command prompt (markdown content with support for $ARGUMENTS, $1, $2, !`commands`, @files) */
+  prompt: string;
+  /** Capability that provides this command */
+  capabilityId: string;
+}
+type CapabilitySourceType = "local" | "git";
+/** Configuration for a Git-sourced capability */
+interface GitCapabilitySourceConfig {
+  /** Source URL or shorthand (e.g., "github:user/repo", "git@github.com:...") */
+  source: string;
+  /** Git ref to checkout: tag, branch, or commit hash */
+  ref?: string;
+  /** Subdirectory within the repo containing the capability */
+  path?: string;
+}
+/** Combined type for all capability source configurations */
+type CapabilitySourceConfig = string | GitCapabilitySourceConfig;
+/** Lock file entry for a capability (version tracking) */
+interface CapabilityLockEntry {
+  /** Original source reference */
+  source: string;
+  /** Version from capability.toml or package.json */
+  version: string;
+  /** For git sources: exact commit hash */
+  commit?: string;
+  /** Pinned ref if specified */
+  ref?: string;
+  /** Last update timestamp (ISO 8601) */
+  updated_at: string;
+}
+/** Lock file structure (omni.lock.toml at project root) */
+interface CapabilitiesLockFile {
+  capabilities: Record<string, CapabilityLockEntry>;
+}
+/** Capabilities configuration section in omni.toml */
+interface CapabilitiesConfig {
+  /** List of enabled capability IDs */
+  enable?: string[];
+  /** List of disabled capability IDs */
+  disable?: string[];
+  /** Capability sources: id -> source string or full config (git or file) */
+  sources?: Record<string, CapabilitySourceConfig>;
+}
+interface ProfileConfig {
+  capabilities?: string[];
+}
+interface OmniConfig {
+  project?: string;
+  active_profile?: string;
+  always_enabled_capabilities?: string[];
+  env?: Record<string, string>;
+  profiles?: Record<string, ProfileConfig>;
+  providers?: {
+    enabled?: Provider[];
+  };
+  /** Capabilities configuration (enable/disable, sources) */
+  capabilities?: CapabilitiesConfig;
+  /** MCP server definitions that auto-generate capabilities */
+  mcps?: Record<string, McpConfig>;
+}
+type Provider = "claude" | "codex" | "claude-code" | "cursor" | "opencode";
+interface ProviderConfig {
+  provider?: Provider;
+  providers?: Provider[];
+}
+declare function getActiveProviders(config: ProviderConfig): Provider[];
+/** Runtime info about where a capability came from */
+interface CapabilitySource {
+  type: CapabilitySourceType;
+  /** For git-sourced capabilities: the source URL/shorthand */
+  gitSource?: string;
+  /** For git-sourced capabilities: the pinned ref if any */
+  ref?: string;
+  /** For git-sourced capabilities: the current commit hash */
+  commit?: string;
+  /** Version from capability.toml or package.json */
+  version?: string;
+}
+interface LoadedCapability {
+  id: string;
+  path: string;
+  config: CapabilityConfig;
+  skills: Skill[];
+  rules: Rule[];
+  docs: Doc[];
+  subagents: Subagent[];
+  commands: Command[];
+  typeDefinitions?: string;
+  gitignore?: string[];
+  exports: Record<string, unknown>;
+  /** Where this capability comes from */
+  source?: CapabilitySource;
+}
+type ProviderId = Provider | (string & {});
+interface SyncBundle {
+  capabilities: LoadedCapability[];
+  skills: Skill[];
+  rules: Rule[];
+  docs: Doc[];
+  commands: Command[];
+  subagents: Subagent[];
+  instructionsPath: string;
+  instructionsContent: string;
+}
+interface ProviderContext {
+  projectRoot: string;
+  config: OmniConfig;
+  activeProfile?: string;
+}
+interface ProviderInitResult {
+  filesCreated?: string[];
+  message?: string;
+}
+interface ProviderSyncResult {
+  filesWritten: string[];
+  filesDeleted: string[];
+}
+interface ProviderManifest {
+  files: string[];
+  lastSync: string;
+}
+interface ProviderAdapter {
+  id: ProviderId;
+  displayName: string;
+  init?(ctx: ProviderContext): Promise<ProviderInitResult>;
+  sync(bundle: SyncBundle, ctx: ProviderContext): Promise<ProviderSyncResult>;
+  cleanup?(manifest: ProviderManifest, ctx: ProviderContext): Promise<void>;
+}
+//#endregion
+//#region src/capability/commands.d.ts
+/**
+ * Load commands from a commands/ directory of a capability.
+ * Each command is a COMMAND.md file in its own subdirectory.
+ */
+declare function loadCommands(capabilityPath: string, capabilityId: string): Promise<Command[]>;
+//#endregion
+//#region src/capability/docs.d.ts
+/**
+ * Load documentation from a capability directory
+ * Loads both definition.md and all files from docs/ directory
+ * @param capabilityPath Path to the capability directory
+ * @param capabilityId ID of the capability
+ * @returns Array of Doc objects
+ */
+declare function loadDocs(capabilityPath: string, capabilityId: string): Promise<Doc[]>;
+//#endregion
+//#region src/capability/loader.d.ts
+/**
+ * Discovers capabilities by scanning the .omni/capabilities directory.
+ * A directory is considered a capability if it contains a capability.toml file.
+ *
+ * @returns Array of capability directory paths
+ */
+declare function discoverCapabilities(): Promise<string[]>;
+/**
+ * Loads and parses a capability configuration file.
+ * Validates required fields.
+ *
+ * @param capabilityPath - Path to the capability directory
+ * @returns Parsed capability configuration
+ * @throws Error if the config is invalid
+ */
+declare function loadCapabilityConfig(capabilityPath: string): Promise<CapabilityConfig>;
+/**
+ * Loads a complete capability including config, skills, rules, docs, and exports.
+ * Validates environment requirements before loading.
+ *
+ * @param capabilityPath - Path to the capability directory
+ * @param env - Environment variables to validate against
+ * @returns Fully loaded capability
+ * @throws Error if validation fails or loading errors occur
+ */
+declare function loadCapability(capabilityPath: string, env: Record<string, string>): Promise<LoadedCapability>;
+//#endregion
+//#region src/capability/registry.d.ts
+/**
+ * Registry of loaded capabilities with helper functions.
+ */
+interface CapabilityRegistry {
+  capabilities: Map<string, LoadedCapability>;
+  getCapability(id: string): LoadedCapability | undefined;
+  getAllCapabilities(): LoadedCapability[];
+  getAllSkills(): Skill[];
+  getAllRules(): Rule[];
+  getAllDocs(): Doc[];
+}
+/**
+ * Builds a capability registry by discovering, loading, and filtering capabilities.
+ * Only enabled capabilities (based on active profile) are included.
+ *
+ * @returns Capability registry with helper functions
+ */
+declare function buildCapabilityRegistry(): Promise<CapabilityRegistry>;
+//#endregion
+//#region src/capability/rules.d.ts
+/**
+ * Load rules from a capability's rules/ directory
+ * @param capabilityPath Path to the capability directory
+ * @param capabilityId ID of the capability
+ * @returns Array of Rule objects
+ */
+declare function loadRules(capabilityPath: string, capabilityId: string): Promise<Rule[]>;
+/**
+ * Write aggregated rules and docs to .omni/instructions.md
+ * Updates the generated section between markers while preserving user content
+ * @param rules Array of rules from all enabled capabilities
+ * @param docs Array of docs from all enabled capabilities
+ */
+declare function writeRules(rules: Rule[], docs?: Doc[]): Promise<void>;
+//#endregion
+//#region src/capability/skills.d.ts
+declare function loadSkills(capabilityPath: string, capabilityId: string): Promise<Skill[]>;
+//#endregion
+//#region src/capability/sources.d.ts
+interface FetchResult {
+  id: string;
+  path: string;
+  version: string;
+  /** Git commit hash */
+  commit?: string;
+  updated: boolean;
+  wrapped: boolean;
+}
+interface SourceUpdateInfo {
+  id: string;
+  source: string;
+  currentVersion: string;
+  latestVersion: string;
+  hasUpdate: boolean;
+}
+/**
+ * Check if a source string is a git source
+ */
+
+/**
+ * Parse a capability source string or config into normalized form
+ * Returns a GitCapabilitySourceConfig
+ */
+declare function parseSourceConfig(source: CapabilitySourceConfig): GitCapabilitySourceConfig;
+/**
+ * Convert source to a git-cloneable URL
+ */
+declare function sourceToGitUrl(source: string): string;
+/**
+ * Get the path where a capability source will be stored
+ */
+declare function getSourceCapabilityPath(id: string): string;
+/**
+ * Get the lock file path
+ */
+declare function getLockFilePath(): string;
+/**
+ * Load the capabilities lock file
+ */
+declare function loadLockFile(): Promise<CapabilitiesLockFile>;
+/**
+ * Save the capabilities lock file
+ */
+declare function saveLockFile(lockFile: CapabilitiesLockFile): Promise<void>;
+/**
+ * Plugin metadata from .claude-plugin/plugin.json
+ */
+
+/**
+ * Discover content in a wrapped repository
+ */
+interface DiscoveredContent {
+  skills: Array<{
+    name: string;
+    path: string;
+    isFolder: boolean;
+  }>;
+  agents: Array<{
+    name: string;
+    path: string;
+    isFolder: boolean;
+  }>;
+  commands: Array<{
+    name: string;
+    path: string;
+    isFolder: boolean;
+  }>;
+  rulesDir: string | null;
+  docsDir: string | null;
+}
+/**
+ * Fetch a single capability source from git
+ */
+declare function fetchCapabilitySource(id: string, sourceConfig: CapabilitySourceConfig, options?: {
+  silent?: boolean;
+}): Promise<FetchResult>;
+/**
+ * Generate synthetic capabilities for MCP definitions in omni.toml
+ */
+
+/**
+ * Fetch all capability sources from config
+ */
+declare function fetchAllCapabilitySources(config: OmniConfig, options?: {
+  silent?: boolean;
+  force?: boolean;
+}): Promise<FetchResult[]>;
+/**
+ * Check for available updates without applying them
+ */
+declare function checkForUpdates(config: OmniConfig): Promise<SourceUpdateInfo[]>;
+//#endregion
+//#region src/capability/subagents.d.ts
+/**
+ * Load subagents from the subagents/ directory of a capability.
+ * Each subagent is a SUBAGENT.md file in its own subdirectory.
+ */
+declare function loadSubagents(capabilityPath: string, capabilityId: string): Promise<Subagent[]>;
+//#endregion
+//#region src/config/capabilities.d.ts
+/**
+ * Get enabled capabilities for the active profile
+ * Includes both profile-specific and always-enabled capabilities
+ * @returns Array of enabled capability IDs
+ */
+declare function getEnabledCapabilities(): Promise<string[]>;
+/**
+ * Enable a capability by adding it to the active profile's capabilities list
+ * @param capabilityId - The ID of the capability to enable
+ */
+declare function enableCapability(capabilityId: string): Promise<void>;
+/**
+ * Disable a capability by removing it from the active profile's capabilities list
+ * @param capabilityId - The ID of the capability to disable
+ */
+declare function disableCapability(capabilityId: string): Promise<void>;
+//#endregion
+//#region src/config/env.d.ts
+/**
+ * Load environment variables from .omni/.env file and merge with process.env.
+ * Process environment variables take precedence over file values.
+ *
+ * @returns Merged environment variables
+ */
+declare function loadEnvironment(): Promise<Record<string, string>>;
+/**
+ * Validate that all required environment variables are present.
+ * Checks declarations from capability config and throws descriptive errors for missing vars.
+ *
+ * @param declarations - Environment variable declarations from capability.toml
+ * @param env - Loaded environment variables
+ * @param capabilityId - ID of the capability being validated
+ * @throws Error if required environment variables are missing
+ */
+declare function validateEnv(declarations: Record<string, EnvDeclaration | Record<string, never>>, env: Record<string, string | undefined>, capabilityId: string): void;
+/**
+ * Check if an environment variable should be treated as a secret.
+ * Secrets should be masked in logs and error messages.
+ *
+ * @param key - Environment variable name
+ * @param declarations - Environment variable declarations from capability.toml
+ * @returns true if the variable is marked as secret
+ */
+declare function isSecretEnvVar(key: string, declarations: Record<string, EnvDeclaration | Record<string, never>>): boolean;
+//#endregion
+//#region src/config/loader.d.ts
+/**
+ * Load and merge config and local configuration files
+ * @returns Merged OmniConfig object
+ *
+ * Reads omni.toml (main config) and omni.local.toml (local overrides).
+ * Local config takes precedence over main config. Missing files are treated as empty configs.
+ */
+declare function loadConfig(): Promise<OmniConfig>;
+/**
+ * Write config to omni.toml at project root
+ * @param config - The config object to write
+ */
+declare function writeConfig(config: OmniConfig): Promise<void>;
+//#endregion
+//#region src/config/parser.d.ts
+/**
+ * Parse a TOML string into an OmniConfig object
+ * @param tomlContent - The TOML content to parse
+ * @returns Parsed OmniConfig object
+ * @throws Error if TOML is invalid
+ */
+declare function parseOmniConfig(tomlContent: string): OmniConfig;
+/**
+ * Parse a TOML string into a CapabilityConfig object
+ * @param tomlContent - The TOML content to parse
+ * @returns Parsed CapabilityConfig object
+ * @throws Error if TOML is invalid or required fields are missing
+ */
+declare function parseCapabilityConfig(tomlContent: string): CapabilityConfig;
+//#endregion
+//#region src/config/profiles.d.ts
+/**
+ * Gets the name of the currently active profile.
+ * Reads from state file first, falls back to config.toml for backwards compatibility.
+ * Returns null if no profile is set.
+ */
+declare function getActiveProfile(): Promise<string | null>;
+/**
+ * Sets the active profile by writing to state file.
+ * @param name - The name of the profile to activate
+ */
+declare function setActiveProfile(name: string): Promise<void>;
+/**
+ * Resolves the enabled capabilities for a given profile
+ *
+ * @param config - The merged OmniConfig
+ * @param profileName - The name of the profile to apply, or null to use active
+ * @returns Array of capability IDs that should be enabled
+ */
+declare function resolveEnabledCapabilities(config: OmniConfig, profileName: string | null): string[];
+/**
+ * Load a specific profile configuration from config.toml
+ * @param profileName - Name of the profile to load
+ * @returns ProfileConfig if found, undefined otherwise
+ */
+declare function loadProfileConfig(profileName: string): Promise<ProfileConfig | undefined>;
+/**
+ * Set a profile configuration in config.toml
+ * @param profileName - Name of the profile to set
+ * @param profileConfig - Profile configuration
+ */
+declare function setProfile(profileName: string, profileConfig: ProfileConfig): Promise<void>;
+//#endregion
+//#region src/config/provider.d.ts
+declare function loadProviderConfig(): Promise<ProviderConfig>;
+declare function writeProviderConfig(config: ProviderConfig): Promise<void>;
+declare function parseProviderFlag(flag: string): Provider[];
+//#endregion
+//#region src/state/manifest.d.ts
+/**
+ * Resources provided by a single capability
+ */
+interface CapabilityResources {
+  skills: string[];
+  rules: string[];
+  commands: string[];
+  subagents: string[];
+  mcps: string[];
+}
+/**
+ * Manifest tracking which resources each capability provides.
+ * Used to clean up stale resources when capabilities are disabled.
+ */
+interface ResourceManifest {
+  /** Schema version for future migrations */
+  version: 1;
+  /** Last sync timestamp (ISO 8601) */
+  syncedAt: string;
+  /** Map of capability ID → resources it provides */
+  capabilities: Record<string, CapabilityResources>;
+}
+/**
+ * Result of cleaning up stale resources
+ */
+interface CleanupResult {
+  deletedSkills: string[];
+  deletedRules: string[];
+  deletedCommands: string[];
+  deletedSubagents: string[];
+  deletedMcps: string[];
+}
+/**
+ * Load the previous manifest from disk.
+ * Returns an empty manifest if the file doesn't exist.
+ */
+declare function loadManifest(): Promise<ResourceManifest>;
+/**
+ * Save the manifest to disk.
+ */
+declare function saveManifest(manifest: ResourceManifest): Promise<void>;
+/**
+ * Build a manifest from the current registry capabilities.
+ */
+declare function buildManifestFromCapabilities(capabilities: LoadedCapability[]): ResourceManifest;
+/**
+ * Delete resources for capabilities that are no longer enabled.
+ * Compares the previous manifest against current capability IDs
+ * and removes files/directories for capabilities not in the current set.
+ */
+declare function cleanupStaleResources(previousManifest: ResourceManifest, currentCapabilityIds: Set<string>): Promise<CleanupResult>;
+//#endregion
+//#region src/mcp-json/manager.d.ts
+/**
+ * MCP server configuration in .mcp.json
+ */
+interface McpServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+/**
+ * Structure of .mcp.json file
+ */
+interface McpJsonConfig {
+  mcpServers: Record<string, McpServerConfig>;
+}
+/**
+ * Read .mcp.json or return empty config if doesn't exist
+ */
+declare function readMcpJson(): Promise<McpJsonConfig>;
+/**
+ * Write .mcp.json, preserving non-OmniDev entries
+ */
+declare function writeMcpJson(config: McpJsonConfig): Promise<void>;
+/**
+ * Sync .mcp.json with enabled capability MCP servers
+ *
+ * Each capability with an [mcp] section is registered using its capability ID.
+ * Uses the previous manifest to track which MCPs were managed by OmniDev.
+ */
+declare function syncMcpJson(capabilities: LoadedCapability[], previousManifest: ResourceManifest, options?: {
+  silent?: boolean;
+}): Promise<void>;
+//#endregion
+//#region src/state/active-profile.d.ts
+/**
+ * Read the active profile from state file.
+ * Returns null if no active profile is set in state.
+ */
+declare function readActiveProfileState(): Promise<string | null>;
+/**
+ * Write the active profile to state file.
+ * @param profileName - The name of the profile to set as active
+ */
+declare function writeActiveProfileState(profileName: string): Promise<void>;
+/**
+ * Clear the active profile state (delete the state file).
+ */
+declare function clearActiveProfileState(): Promise<void>;
+//#endregion
+//#region src/state/providers.d.ts
+interface ProvidersState {
+  enabled: ProviderId[];
+}
+/**
+ * Read the enabled providers from local state.
+ * Returns default providers if no state file exists.
+ */
+declare function readEnabledProviders(): Promise<ProviderId[]>;
+/**
+ * Write enabled providers to local state.
+ * @param providers - List of provider IDs to enable
+ */
+declare function writeEnabledProviders(providers: ProviderId[]): Promise<void>;
+/**
+ * Enable a specific provider.
+ * @param providerId - The provider to enable
+ */
+declare function enableProvider(providerId: ProviderId): Promise<void>;
+/**
+ * Disable a specific provider.
+ * @param providerId - The provider to disable
+ */
+declare function disableProvider(providerId: ProviderId): Promise<void>;
+/**
+ * Check if a provider is enabled.
+ * @param providerId - The provider to check
+ */
+declare function isProviderEnabled(providerId: ProviderId): Promise<boolean>;
+//#endregion
+//#region src/sync.d.ts
+interface SyncResult {
+  capabilities: string[];
+  skillCount: number;
+  ruleCount: number;
+  docCount: number;
+}
+interface SyncOptions {
+  silent?: boolean;
+  /** Optional list of adapters to run. If not provided, adapters are not run. */
+  adapters?: ProviderAdapter[];
+}
+/**
+ * Install dependencies for capabilities in .omni/capabilities/
+ * Only installs for capabilities that have a package.json
+ */
+declare function installCapabilityDependencies(silent: boolean): Promise<void>;
+/**
+ * Build a provider-agnostic SyncBundle from the capability registry.
+ * This bundle can then be passed to adapters for provider-specific materialization.
+ */
+declare function buildSyncBundle(options?: {
+  silent?: boolean;
+}): Promise<{
+  bundle: SyncBundle;
+}>;
+/**
+ * Central sync function that regenerates all agent configuration files.
+ * Called automatically after any config change (init, capability enable/disable, profile change).
+ *
+ * If adapters are provided, they will be called after core sync to write provider-specific files.
+ */
+declare function syncAgentConfiguration(options?: SyncOptions): Promise<SyncResult>;
+//#endregion
+//#region src/templates/agents.d.ts
+/**
+ * Template for AGENTS.md (Codex provider)
+ * Creates a minimal file with reference to OmniDev instructions
+ */
+declare function generateAgentsTemplate(): string;
+//#endregion
+//#region src/templates/claude.d.ts
+/**
+ * Template for CLAUDE.md (Claude provider)
+ * Creates a minimal file with reference to OmniDev instructions
+ */
+declare function generateClaudeTemplate(): string;
+/**
+ * Template for .omni/instructions.md
+ * Contains OmniDev-specific instructions and capability rules
+ */
+declare function generateInstructionsTemplate(): string;
+//#endregion
+//#region src/debug.d.ts
+/**
+ * Debug logger that writes to stdout when OMNIDEV_DEBUG=1
+ */
+declare function debug(message: string, data?: unknown): void;
+//#endregion
+//#region src/index.d.ts
+declare const version = "0.1.0";
+declare function getVersion(): string;
+//#endregion
+export { CapabilitiesConfig, CapabilitiesLockFile, CapabilityConfig, CapabilityExport, CapabilityExports, CapabilityLockEntry, CapabilityMetadata, CapabilityRegistry, CapabilityResources, CapabilitySource, CapabilitySourceConfig, CapabilitySourceType, CleanupResult, CliConfig, Command, CommandExport, DiscoveredContent, Doc, DocExport, EnvDeclaration, FetchResult, FileContent, GitCapabilitySourceConfig, LoadedCapability, McpConfig, McpJsonConfig, McpServerConfig, McpToolSchema, McpTransport, OmniConfig, ProfileConfig, Provider, ProviderAdapter, ProviderConfig, ProviderContext, ProviderId, ProviderInitResult, ProviderManifest, ProviderSyncResult, ProvidersState, ResourceManifest, Rule, Skill, SkillExport, SourceUpdateInfo, Subagent, SubagentExport, SubagentHookConfig, SubagentHooks, SubagentModel, SubagentPermissionMode, SyncBundle, SyncConfig, SyncOptions, SyncResult, buildCapabilityRegistry, buildCommand, buildManifestFromCapabilities, buildRouteMap, buildSyncBundle, checkForUpdates, cleanupStaleResources, clearActiveProfileState, debug, disableCapability, disableProvider, discoverCapabilities, enableCapability, enableProvider, fetchAllCapabilitySources, fetchCapabilitySource, generateAgentsTemplate, generateClaudeTemplate, generateInstructionsTemplate, getActiveProfile, getActiveProviders, getEnabledCapabilities, getLockFilePath, getSourceCapabilityPath, getVersion, installCapabilityDependencies, isProviderEnabled, isSecretEnvVar, loadCapability, loadCapabilityConfig, loadCommands, loadConfig, loadDocs, loadEnvironment, loadLockFile, loadManifest, loadProfileConfig, loadProviderConfig, loadRules, loadSkills, loadSubagents, parseCapabilityConfig, parseOmniConfig, parseProviderFlag, parseSourceConfig, readActiveProfileState, readEnabledProviders, readMcpJson, resolveEnabledCapabilities, saveLockFile, saveManifest, setActiveProfile, setProfile, sourceToGitUrl, syncAgentConfiguration, syncMcpJson, validateEnv, version, writeActiveProfileState, writeConfig, writeEnabledProviders, writeMcpJson, writeProviderConfig, writeRules };