@omnidev-ai/core 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -0,0 +1,825 @@
+import { buildCommand, buildRouteMap } from "@stricli/core";
+/**
+* Capability Export Types
+*
+* These types define the structure that capabilities use to 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 structure
+*/
+interface DocExport {
+	/** Document title */
+	title: string;
+	/** Markdown content */
+	content: string;
+}
+/**
+* Skill 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 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 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 structure
+*
+* Capabilities this as their default 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 CLI commands
+* {
+*   cliCommands: { mycap: myRoutes },
+*   gitignore: ["mycap/"],
+*   sync
+* } satisfies CapabilityExport;
+* ```
+*
+* @example
+* ```typescript
+* // Programmatic approach - generate content dynamically
+* {
+*   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;
+}
+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>;
+}
+/**
+* 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[]>;
+/**
+* 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[]>;
+/**
+* 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>;
+/**
+* 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>;
+/**
+* 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>;
+declare function loadSkills(capabilityPath: string, capabilityId: string): Promise<Skill[]>;
+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;
+}
+/**
+* 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>;
+/**
+* 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>;
+/**
+* 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[]>;
+/**
+* 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[]>;
+/**
+* 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>;
+/**
+* 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;
+/**
+* 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>;
+/**
+* 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;
+/**
+* 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>;
+declare function loadProviderConfig(): Promise<ProviderConfig>;
+declare function writeProviderConfig(config: ProviderConfig): Promise<void>;
+declare function parseProviderFlag(flag: string): Provider[];
+/**
+* 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>;
+/**
+* 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>;
+/**
+* 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>;
+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>;
+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>;
+/**
+* Template for AGENTS.md (Codex provider)
+* Creates a minimal file with reference to OmniDev instructions
+*/
+declare function generateAgentsTemplate(): string;
+/**
+* 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;
+/**
+* Debug logger that writes to stdout when OMNIDEV_DEBUG=1
+*/
+declare function debug(message: string, data?: unknown): void;
+declare const version = "0.1.0";
+declare function getVersion(): string;
+export { writeRules, writeProviderConfig, writeMcpJson, writeEnabledProviders, writeConfig, writeActiveProfileState, version, validateEnv, syncMcpJson, syncAgentConfiguration, sourceToGitUrl, setProfile, setActiveProfile, saveManifest, saveLockFile, resolveEnabledCapabilities, readMcpJson, readEnabledProviders, readActiveProfileState, parseSourceConfig, parseProviderFlag, parseOmniConfig, parseCapabilityConfig, loadSubagents, loadSkills, loadRules, loadProviderConfig, loadProfileConfig, loadManifest, loadLockFile, loadEnvironment, loadDocs, loadConfig, loadCommands, loadCapabilityConfig, loadCapability, isSecretEnvVar, isProviderEnabled, installCapabilityDependencies, getVersion, getSourceCapabilityPath, getLockFilePath, getEnabledCapabilities, getActiveProviders, getActiveProfile, generateInstructionsTemplate, generateClaudeTemplate, generateAgentsTemplate, fetchCapabilitySource, fetchAllCapabilitySources, enableProvider, enableCapability, discoverCapabilities, disableProvider, disableCapability, debug, clearActiveProfileState, cleanupStaleResources, checkForUpdates, buildSyncBundle, buildRouteMap, buildManifestFromCapabilities, buildCommand, buildCapabilityRegistry, SyncResult, SyncOptions, SyncConfig, SyncBundle, SubagentPermissionMode, SubagentModel, SubagentHooks, SubagentHookConfig, SubagentExport, Subagent, SourceUpdateInfo, SkillExport, Skill, Rule, ResourceManifest, ProvidersState, ProviderSyncResult, ProviderManifest, ProviderInitResult, ProviderId, ProviderContext, ProviderConfig, ProviderAdapter, Provider, ProfileConfig, OmniConfig, McpTransport, McpToolSchema, McpServerConfig, McpJsonConfig, McpConfig, LoadedCapability, GitCapabilitySourceConfig, FileContent, FetchResult, EnvDeclaration, DocExport, Doc, DiscoveredContent, CommandExport, Command, CliConfig, CleanupResult, CapabilitySourceType, CapabilitySourceConfig, CapabilitySource, CapabilityResources, CapabilityRegistry, CapabilityMetadata, CapabilityLockEntry, CapabilityExports, CapabilityExport, CapabilityConfig, CapabilitiesLockFile, CapabilitiesConfig };