@lnai/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Krystian Jonca
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,313 @@
+import { z } from 'zod';
+
+declare const UNIFIED_DIR = ".ai";
+declare const TOOL_IDS: readonly ["claudeCode", "opencode"];
+type ToolId = (typeof TOOL_IDS)[number];
+declare const CONFIG_FILES: {
+    readonly config: "config.json";
+    readonly settings: "settings.json";
+    readonly agents: "AGENTS.md";
+};
+declare const CONFIG_DIRS: {
+    readonly rules: "rules";
+    readonly skills: "skills";
+    readonly subagents: "subagents";
+};
+declare const TOOL_OUTPUT_DIRS: Record<ToolId, string>;
+
+declare class LnaiError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+declare class ParseError extends LnaiError {
+    readonly filePath: string;
+    constructor(message: string, filePath: string, cause?: Error);
+}
+declare class ValidationError extends LnaiError {
+    readonly path: string[];
+    readonly value?: unknown;
+    constructor(message: string, path: string[], value?: unknown);
+}
+declare class FileNotFoundError extends LnaiError {
+    readonly filePath: string;
+    constructor(message: string, filePath: string);
+}
+declare class WriteError extends LnaiError {
+    readonly filePath: string;
+    constructor(message: string, filePath: string, cause?: Error);
+}
+declare class PluginError extends LnaiError {
+    readonly pluginId: string;
+    constructor(message: string, pluginId: string, cause?: Error);
+}
+
+/** MCP Server configuration (Claude format as source of truth) */
+declare const mcpServerSchema: z.ZodObject<{
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        http: "http";
+        sse: "sse";
+    }>>;
+    url: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+declare const permissionsSchema: z.ZodObject<{
+    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ask: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const toolConfigSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    versionControl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+declare const toolIdSchema: z.ZodEnum<{
+    claudeCode: "claudeCode";
+    opencode: "opencode";
+}>;
+/** Settings configuration (Claude format as source of truth) */
+declare const settingsSchema: z.ZodObject<{
+    permissions: z.ZodOptional<z.ZodObject<{
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        ask: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        type: z.ZodOptional<z.ZodEnum<{
+            http: "http";
+            sse: "sse";
+        }>>;
+        url: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>>;
+    overrides: z.ZodOptional<z.ZodObject<{
+        claudeCode: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        opencode: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Main config.json structure. Uses partial object to allow partial tool configs. */
+declare const configSchema: z.ZodObject<{
+    tools: z.ZodOptional<z.ZodObject<{
+        claudeCode: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            versionControl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>>;
+        opencode: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            versionControl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Skill frontmatter (name and description required) */
+declare const skillFrontmatterSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+/** Rule frontmatter (paths required) */
+declare const ruleFrontmatterSchema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type McpServer = z.infer<typeof mcpServerSchema>;
+type Permissions = z.infer<typeof permissionsSchema>;
+type ToolConfig = z.infer<typeof toolConfigSchema>;
+type Settings = z.infer<typeof settingsSchema>;
+type Config = z.infer<typeof configSchema>;
+type SkillFrontmatter = z.infer<typeof skillFrontmatterSchema>;
+type RuleFrontmatter = z.infer<typeof ruleFrontmatterSchema>;
+
+type PermissionLevel = "allow" | "ask" | "deny";
+interface MarkdownFile<T = unknown> {
+    path: string;
+    frontmatter: T;
+    content: string;
+}
+/** @deprecated Use typed MarkdownFile<T> instead */
+interface MarkdownFrontmatter {
+    description?: string;
+    paths?: string[];
+    name?: string;
+}
+/** All parsed configuration from the .ai directory */
+interface UnifiedState {
+    config: {
+        tools?: Partial<Record<ToolId, {
+            enabled: boolean;
+            versionControl?: boolean;
+        }>>;
+    };
+    settings: {
+        permissions?: {
+            allow?: string[];
+            ask?: string[];
+            deny?: string[];
+        };
+        mcpServers?: Record<string, unknown>;
+        overrides?: Partial<Record<ToolId, Record<string, unknown>>>;
+    } | null;
+    agents: string | null;
+    rules: MarkdownFile<RuleFrontmatter>[];
+    skills: MarkdownFile<SkillFrontmatter>[];
+}
+interface OutputFile {
+    path: string;
+    type: "json" | "text" | "symlink";
+    content?: unknown;
+    target?: string;
+}
+interface ValidationErrorDetail {
+    path: string[];
+    message: string;
+    value?: unknown;
+}
+interface ValidationWarningDetail {
+    path: string[];
+    message: string;
+}
+/** Feature not supported by a particular tool */
+interface SkippedFeatureDetail {
+    feature: string;
+    reason: string;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationErrorDetail[];
+    warnings: ValidationWarningDetail[];
+    skipped: SkippedFeatureDetail[];
+}
+interface ChangeResult {
+    path: string;
+    action: "create" | "update" | "delete" | "unchanged";
+    oldHash?: string;
+    newHash?: string;
+}
+interface SyncResult {
+    tool: ToolId;
+    changes: ChangeResult[];
+    validation: ValidationResult;
+}
+
+declare function parseFrontmatter(content: string): {
+    frontmatter: Record<string, unknown>;
+    content: string;
+};
+
+/**
+ * Parse the unified .ai/ configuration directory.
+ * Reads config.json, settings.json, AGENTS.md, rules, and skills.
+ */
+declare function parseUnifiedConfig(rootDir: string): Promise<UnifiedState>;
+
+/**
+ * Validate config.json structure using Zod
+ */
+declare function validateConfig(config: unknown): ValidationResult;
+/**
+ * Validate settings.json structure using Zod
+ */
+declare function validateSettings(settings: unknown): ValidationResult;
+/**
+ * Validate the unified configuration state
+ * @param state - Parsed unified state
+ * @returns Validation result
+ */
+declare function validateUnifiedState(state: UnifiedState): ValidationResult;
+
+interface Plugin {
+    id: ToolId;
+    name: string;
+    /** Detect if this tool's configuration exists in the given directory */
+    detect(rootDir: string): Promise<boolean>;
+    /** Import existing tool configuration into unified state */
+    import(rootDir: string): Promise<Partial<UnifiedState> | null>;
+    /** Export unified state to this tool's native format */
+    export(state: UnifiedState, rootDir: string): Promise<OutputFile[]>;
+    /** Validate unified state for this tool */
+    validate(state: UnifiedState): ValidationResult;
+}
+
+/**
+ * Claude Code plugin for exporting to .claude/ format
+ *
+ * Output structure:
+ * - .claude/CLAUDE.md (symlink -> ../.ai/AGENTS.md)
+ * - .claude/rules/ (symlink -> ../.ai/rules)
+ * - .claude/skills/<name>/ (symlink -> ../../.ai/skills/<name>)
+ * - .claude/settings.json (generated settings merged with .ai/.claude/settings.json)
+ * - .claude/<path> (symlink -> ../.ai/.claude/<path>) for other override files
+ */
+declare const claudeCodePlugin: Plugin;
+
+/**
+ * OpenCode plugin for exporting to opencode.json format
+ *
+ * Output structure:
+ * - .opencode/AGENTS.md (symlink -> ../.ai/AGENTS.md)
+ * - .opencode/rules/ (symlink -> ../.ai/rules)
+ * - .opencode/skills/<name>/ (symlink -> ../../.ai/skills/<name>)
+ * - opencode.json (generated config merged with .ai/.opencode/opencode.json)
+ * - .opencode/<path> (symlink -> ../.ai/.opencode/<path>) for other override files
+ */
+declare const opencodePlugin: Plugin;
+
+declare class PluginRegistry {
+    private plugins;
+    register(plugin: Plugin): void;
+    get(id: ToolId): Plugin | undefined;
+    getAll(): Plugin[];
+    getIds(): ToolId[];
+    has(id: ToolId): boolean;
+}
+declare const pluginRegistry: PluginRegistry;
+
+/**
+ * Options for the sync pipeline
+ */
+interface SyncOptions {
+    /** Root directory containing .ai/ config */
+    rootDir: string;
+    /** Only sync specific tools (default: all enabled) */
+    tools?: ToolId[];
+    /** Preview changes without writing files */
+    dryRun?: boolean;
+    /** Enable verbose output */
+    verbose?: boolean;
+}
+/**
+ * Run the sync pipeline to export .ai/ config to native tool formats.
+ */
+declare function runSyncPipeline(options: SyncOptions): Promise<SyncResult[]>;
+
+/**
+ * Options for the file writer
+ */
+interface WriterOptions {
+    /** Root directory for output */
+    rootDir: string;
+    /** Preview changes without writing */
+    dryRun?: boolean;
+}
+declare function computeHash(content: string): string;
+declare function writeFiles(files: OutputFile[], options: WriterOptions): Promise<ChangeResult[]>;
+/**
+ * Update .gitignore with paths that should not be version controlled.
+ * Manages a dedicated "lnai-generated" section to avoid conflicts with user entries.
+ */
+declare function updateGitignore(rootDir: string, paths: string[]): Promise<void>;
+
+interface InitOptions {
+    rootDir: string;
+    tools?: ToolId[];
+    minimal?: boolean;
+}
+interface InitResult {
+    created: string[];
+}
+declare function hasUnifiedConfig(rootDir: string): Promise<boolean>;
+declare function generateDefaultConfig(tools?: ToolId[]): Config;
+declare function initUnifiedConfig(options: InitOptions): Promise<InitResult>;
+
+export { CONFIG_DIRS, CONFIG_FILES, type ChangeResult, type Config, FileNotFoundError, type InitOptions, type InitResult, LnaiError, type MarkdownFile, type MarkdownFrontmatter, type McpServer, type OutputFile, ParseError, type PermissionLevel, type Permissions, type Plugin, PluginError, type RuleFrontmatter, type Settings, type SkillFrontmatter, type SkippedFeatureDetail, type SyncOptions, type SyncResult, TOOL_IDS, TOOL_OUTPUT_DIRS, type ToolConfig, type ToolId, UNIFIED_DIR, type UnifiedState, ValidationError, type ValidationErrorDetail, type ValidationResult, type ValidationWarningDetail, WriteError, type WriterOptions, claudeCodePlugin, computeHash, configSchema, generateDefaultConfig, hasUnifiedConfig, initUnifiedConfig, mcpServerSchema, opencodePlugin, parseFrontmatter, parseUnifiedConfig, permissionsSchema, pluginRegistry, ruleFrontmatterSchema, runSyncPipeline, settingsSchema, skillFrontmatterSchema, toolConfigSchema, toolIdSchema, updateGitignore, validateConfig, validateSettings, validateUnifiedState, writeFiles };