mozaic-mcp-server 1.0.0

package/dist/db/schema.js

@@ -0,0 +1,253 @@
+export const SCHEMA = `
+-- Design Tokens (enhanced schema)
+CREATE TABLE IF NOT EXISTS tokens (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  category TEXT NOT NULL,           -- 'color', 'spacing', 'shadow', 'border', 'radius', 'screen', 'typography'
+  subcategory TEXT,                 -- 'primary', 'grey', 'font', 'line', etc.
+  name TEXT NOT NULL,               -- 'primary-01-100', 'mu100', 's'
+  path TEXT NOT NULL UNIQUE,        -- Full path: 'color.primary-01.100'
+  css_variable TEXT,                -- '--color-primary-01-100'
+  scss_variable TEXT,               -- '$color-primary-01-100' or '$mu100'
+
+  -- Values (multiple formats)
+  value_raw TEXT NOT NULL,          -- Original value as-is
+  value_number REAL,                -- Numeric value (if applicable)
+  value_unit TEXT,                  -- 'px', 'rem', '%', 'hex', etc.
+  value_computed TEXT,              -- Computed value (e.g., '16px' for 1rem)
+
+  -- Metadata
+  description TEXT,
+  platform TEXT DEFAULT 'all',
+  source_file TEXT                  -- Where it came from
+);
+
+-- For composite tokens like shadows
+CREATE TABLE IF NOT EXISTS token_properties (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  token_id INTEGER NOT NULL REFERENCES tokens(id) ON DELETE CASCADE,
+  property TEXT NOT NULL,           -- 'x', 'y', 'blur', 'spread', 'opacity'
+  value TEXT NOT NULL,
+  value_number REAL,
+  value_unit TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_token_properties_token ON token_properties(token_id);
+
+-- Token indexes for fast queries
+CREATE INDEX IF NOT EXISTS idx_tokens_category ON tokens(category);
+CREATE INDEX IF NOT EXISTS idx_tokens_subcategory ON tokens(category, subcategory);
+CREATE INDEX IF NOT EXISTS idx_tokens_path ON tokens(path);
+CREATE INDEX IF NOT EXISTS idx_tokens_css_var ON tokens(css_variable);
+CREATE INDEX IF NOT EXISTS idx_tokens_scss_var ON tokens(scss_variable);
+
+-- Full-text search on tokens
+CREATE VIRTUAL TABLE IF NOT EXISTS tokens_fts USING fts5(
+  name,
+  path,
+  description,
+  css_variable,
+  scss_variable,
+  content=tokens,
+  content_rowid=id
+);
+
+-- Triggers to keep tokens FTS index in sync
+CREATE TRIGGER IF NOT EXISTS tokens_ai AFTER INSERT ON tokens BEGIN
+  INSERT INTO tokens_fts(rowid, name, path, description, css_variable, scss_variable)
+  VALUES (new.id, new.name, new.path, new.description, new.css_variable, new.scss_variable);
+END;
+
+CREATE TRIGGER IF NOT EXISTS tokens_ad AFTER DELETE ON tokens BEGIN
+  INSERT INTO tokens_fts(tokens_fts, rowid, name, path, description, css_variable, scss_variable)
+  VALUES('delete', old.id, old.name, old.path, old.description, old.css_variable, old.scss_variable);
+END;
+
+CREATE TRIGGER IF NOT EXISTS tokens_au AFTER UPDATE ON tokens BEGIN
+  INSERT INTO tokens_fts(tokens_fts, rowid, name, path, description, css_variable, scss_variable)
+  VALUES('delete', old.id, old.name, old.path, old.description, old.css_variable, old.scss_variable);
+  INSERT INTO tokens_fts(rowid, name, path, description, css_variable, scss_variable)
+  VALUES (new.id, new.name, new.path, new.description, new.css_variable, new.scss_variable);
+END;
+
+-- Components
+CREATE TABLE IF NOT EXISTS components (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  slug TEXT NOT NULL,
+  category TEXT,
+  description TEXT,
+  frameworks TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_components_category ON components(category);
+CREATE INDEX IF NOT EXISTS idx_components_slug ON components(slug);
+
+-- Component Props
+CREATE TABLE IF NOT EXISTS component_props (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  component_id INTEGER REFERENCES components(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  type TEXT,
+  default_value TEXT,
+  required INTEGER DEFAULT 0,
+  options TEXT,
+  description TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_component_props_component ON component_props(component_id);
+
+-- Component Slots
+CREATE TABLE IF NOT EXISTS component_slots (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  component_id INTEGER REFERENCES components(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  description TEXT
+);
+
+-- Component Events
+CREATE TABLE IF NOT EXISTS component_events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  component_id INTEGER REFERENCES components(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  payload TEXT,
+  description TEXT
+);
+
+-- Component Examples
+CREATE TABLE IF NOT EXISTS component_examples (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  component_id INTEGER REFERENCES components(id) ON DELETE CASCADE,
+  framework TEXT NOT NULL,
+  title TEXT,
+  code TEXT NOT NULL,
+  description TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_component_examples_component ON component_examples(component_id);
+CREATE INDEX IF NOT EXISTS idx_component_examples_framework ON component_examples(framework);
+
+-- CSS Classes (for framework components)
+CREATE TABLE IF NOT EXISTS component_css_classes (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  component_id INTEGER REFERENCES components(id) ON DELETE CASCADE,
+  class_name TEXT NOT NULL,
+  description TEXT
+);
+
+-- CSS Utilities (layouts & spacing - separate from framework components)
+CREATE TABLE IF NOT EXISTS css_utilities (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  slug TEXT NOT NULL,
+  category TEXT NOT NULL,
+  description TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_css_utilities_category ON css_utilities(category);
+CREATE INDEX IF NOT EXISTS idx_css_utilities_slug ON css_utilities(slug);
+
+-- CSS Utility Classes
+CREATE TABLE IF NOT EXISTS css_utility_classes (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  utility_id INTEGER REFERENCES css_utilities(id) ON DELETE CASCADE,
+  class_name TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_css_utility_classes_utility ON css_utility_classes(utility_id);
+
+-- CSS Utility Examples
+CREATE TABLE IF NOT EXISTS css_utility_examples (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  utility_id INTEGER REFERENCES css_utilities(id) ON DELETE CASCADE,
+  title TEXT,
+  code TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_css_utility_examples_utility ON css_utility_examples(utility_id);
+
+-- Documentation
+CREATE TABLE IF NOT EXISTS documentation (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  title TEXT NOT NULL,
+  path TEXT NOT NULL,
+  content TEXT NOT NULL,
+  category TEXT,
+  keywords TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_documentation_category ON documentation(category);
+CREATE INDEX IF NOT EXISTS idx_documentation_path ON documentation(path);
+
+-- Full-text search for documentation
+CREATE VIRTUAL TABLE IF NOT EXISTS docs_fts USING fts5(
+  title,
+  content,
+  keywords,
+  content=documentation,
+  content_rowid=id
+);
+
+-- Triggers to keep FTS index in sync
+CREATE TRIGGER IF NOT EXISTS docs_ai AFTER INSERT ON documentation BEGIN
+  INSERT INTO docs_fts(rowid, title, content, keywords)
+  VALUES (new.id, new.title, new.content, new.keywords);
+END;
+
+CREATE TRIGGER IF NOT EXISTS docs_ad AFTER DELETE ON documentation BEGIN
+  INSERT INTO docs_fts(docs_fts, rowid, title, content, keywords)
+  VALUES('delete', old.id, old.title, old.content, old.keywords);
+END;
+
+CREATE TRIGGER IF NOT EXISTS docs_au AFTER UPDATE ON documentation BEGIN
+  INSERT INTO docs_fts(docs_fts, rowid, title, content, keywords)
+  VALUES('delete', old.id, old.title, old.content, old.keywords);
+  INSERT INTO docs_fts(rowid, title, content, keywords)
+  VALUES (new.id, new.title, new.content, new.keywords);
+END;
+
+-- Icons
+CREATE TABLE IF NOT EXISTS icons (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,           -- 'ArrowArrowBottom16'
+  icon_name TEXT NOT NULL,             -- 'ArrowArrowBottom' (without size)
+  type TEXT NOT NULL,                  -- 'navigation', 'media', 'action', etc.
+  size INTEGER NOT NULL,               -- 16, 24, 32, 48, 64
+  view_box TEXT NOT NULL,              -- '0 0 16 16'
+  paths TEXT NOT NULL                  -- JSON array of SVG paths
+);
+
+CREATE INDEX IF NOT EXISTS idx_icons_type ON icons(type);
+CREATE INDEX IF NOT EXISTS idx_icons_size ON icons(size);
+CREATE INDEX IF NOT EXISTS idx_icons_name ON icons(icon_name);
+
+-- Full-text search for icons
+CREATE VIRTUAL TABLE IF NOT EXISTS icons_fts USING fts5(
+  name,
+  icon_name,
+  type,
+  content=icons,
+  content_rowid=id
+);
+
+-- Triggers to keep icons FTS index in sync
+CREATE TRIGGER IF NOT EXISTS icons_ai AFTER INSERT ON icons BEGIN
+  INSERT INTO icons_fts(rowid, name, icon_name, type)
+  VALUES (new.id, new.name, new.icon_name, new.type);
+END;
+
+CREATE TRIGGER IF NOT EXISTS icons_ad AFTER DELETE ON icons BEGIN
+  INSERT INTO icons_fts(icons_fts, rowid, name, icon_name, type)
+  VALUES('delete', old.id, old.name, old.icon_name, old.type);
+END;
+
+CREATE TRIGGER IF NOT EXISTS icons_au AFTER UPDATE ON icons BEGIN
+  INSERT INTO icons_fts(icons_fts, rowid, name, icon_name, type)
+  VALUES('delete', old.id, old.name, old.icon_name, old.type);
+  INSERT INTO icons_fts(rowid, name, icon_name, type)
+  VALUES (new.id, new.name, new.icon_name, new.type);
+END;
+`;
+export function initSchema(db) {
+    db.exec(SCHEMA);
+}
+//# sourceMappingURL=schema.js.map

package/dist/db/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/db/schema.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwPrB,CAAC;AAEF,MAAM,UAAU,UAAU,CAAC,EAAqB;IAC9C,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAClB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,416 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import Database from "better-sqlite3";
+import { appendFileSync, existsSync, readFileSync, readdirSync, mkdirSync, copyFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+// Debug mode - enable with --debug flag
+const DEBUG = process.argv.includes("--debug");
+const LOG_FILE = join(dirname(fileURLToPath(import.meta.url)), "..", "mcp-server.log");
+function log(message, data) {
+    if (!DEBUG)
+        return;
+    const timestamp = new Date().toISOString();
+    const logMessage = data
+        ? `[${timestamp}] ${message}: ${JSON.stringify(data, null, 2)}\n`
+        : `[${timestamp}] ${message}\n`;
+    appendFileSync(LOG_FILE, logMessage);
+}
+// Import tool handlers
+import { handleGenerateReactComponent, } from "./tools/generate-react-component.js";
+import { handleGenerateVueComponent, } from "./tools/generate-vue-component.js";
+import { handleGetComponentInfo } from "./tools/get-component-info.js";
+import { handleGetCssUtility } from "./tools/get-css-utility.js";
+import { handleGetDesignTokens } from "./tools/get-design-tokens.js";
+import { handleListComponents } from "./tools/list-components.js";
+import { handleListCssUtilities } from "./tools/list-css-utilities.js";
+import { handleSearchDocumentation, } from "./tools/search-documentation.js";
+import { handleSearchIcons } from "./tools/search-icons.js";
+import { handleGetIcon } from "./tools/get-icon.js";
+import { handleGetInstallInfo } from "./tools/get-install-info.js";
+// Get database path
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const dbPath = join(__dirname, "..", "data", "mozaic.db");
+// Initialize database
+let db;
+function initializeDatabase() {
+    log("Initializing database", { path: dbPath });
+    if (!existsSync(dbPath)) {
+        const error = `Database not found at ${dbPath}. Run 'npm run build' to build the database first.`;
+        log("Database error", { error });
+        throw new Error(error);
+    }
+    const database = new Database(dbPath, { readonly: true });
+    database.pragma("journal_mode = WAL");
+    log("Database initialized successfully");
+    return database;
+}
+// Create MCP server
+const server = new McpServer({
+    name: "mozaic-design-system",
+    version: "1.0.0",
+});
+// Register tools using the new McpServer API
+log("Registering MCP tools");
+server.registerTool("get_design_tokens", {
+    description: "Get Mozaic design tokens with CSS/SCSS variables. Categories: colors (brand, semantic, component), typography (font sizes, weights, line heights), spacing (magic unit scale), shadows, borders, screens (breakpoints), grid (gutters).",
+    inputSchema: {
+        category: z
+            .enum(["colors", "typography", "spacing", "shadows", "borders", "screens", "grid", "all"])
+            .describe("Token category: colors, typography, spacing, shadows, borders, screens, grid, or all"),
+        format: z
+            .enum(["json", "scss", "css", "js"])
+            .default("json")
+            .describe("Output format: json (structured), scss ($variables), css (--custom-properties), js (constants)"),
+    },
+}, async (args) => {
+    log("Tool called: get_design_tokens", args);
+    if (!db)
+        db = initializeDatabase();
+    const result = handleGetDesignTokens(db, args);
+    log("Tool result: get_design_tokens", { contentLength: result.content.length });
+    return result;
+});
+server.registerTool("get_component_info", {
+    description: "Get Vue/React component details: props (types, defaults, required), slots, events, and code examples. For CSS-only utilities (Flexy, Margin, Padding), use get_css_utility instead.",
+    inputSchema: {
+        component: z
+            .string()
+            .describe("Component name (e.g., 'button', 'modal', 'accordion', 'text-input')"),
+        framework: z
+            .enum(["vue", "react"])
+            .default("vue")
+            .describe("Framework for code examples: vue (@mozaic-ds/vue-3) or react (@mozaic-ds/react)"),
+    },
+}, async (args) => {
+    log("Tool called: get_component_info", args);
+    if (!db)
+        db = initializeDatabase();
+    const result = handleGetComponentInfo(db, args);
+    log("Tool result: get_component_info", { contentLength: result.content.length });
+    return result;
+});
+server.registerTool("list_components", {
+    description: "List Mozaic Vue/React components by category. Returns component names you can use with get_component_info. For CSS utilities (Flexy, Margin), use list_css_utilities instead.",
+    inputSchema: {
+        category: z
+            .enum(["form", "navigation", "feedback", "layout", "data-display", "action", "all"])
+            .default("all")
+            .describe("Filter: form (inputs, selects), navigation (tabs, breadcrumb), feedback (modal, toast), layout, data-display, action (buttons), or all"),
+    },
+}, async (args) => {
+    log("Tool called: list_components", args);
+    if (!db)
+        db = initializeDatabase();
+    const result = handleListComponents(db, args);
+    log("Tool result: list_components", { contentLength: result.content.length });
+    return result;
+});
+server.registerTool("generate_vue_component", {
+    description: "Generate ready-to-use Vue 3 code with Mozaic components (@mozaic-ds/vue-3). Returns <template> with proper imports. Use get_component_info first to see available props.",
+    inputSchema: {
+        component: z
+            .string()
+            .describe("Component to generate (e.g., 'button', 'text-input', 'modal', 'select')"),
+        props: z
+            .record(z.unknown())
+            .optional()
+            .describe("Props to apply (e.g., {theme: 'primary', size: 'm'})"),
+        children: z.string().optional().describe("Slot content (text or HTML)"),
+    },
+}, async (args) => {
+    log("Tool called: generate_vue_component", args);
+    if (!db)
+        db = initializeDatabase();
+    const result = handleGenerateVueComponent(db, args);
+    log("Tool result: generate_vue_component", { contentLength: result.content.length });
+    return result;
+});
+server.registerTool("generate_react_component", {
+    description: "Generate ready-to-use React/TSX code with Mozaic components (@mozaic-ds/react). Returns JSX with proper imports. Use get_component_info first to see available props.",
+    inputSchema: {
+        component: z
+            .string()
+            .describe("Component to generate (e.g., 'Button', 'TextInput', 'Modal', 'Select')"),
+        props: z
+            .record(z.unknown())
+            .optional()
+            .describe("Props to apply (e.g., {theme: 'primary', size: 'm'})"),
+        children: z.string().optional().describe("Children content (text or JSX)"),
+    },
+}, async (args) => {
+    log("Tool called: generate_react_component", args);
+    if (!db)
+        db = initializeDatabase();
+    const result = handleGenerateReactComponent(db, args);
+    log("Tool result: generate_react_component", { contentLength: result.content.length });
+    return result;
+});
+server.registerTool("search_documentation", {
+    description: "Search Mozaic Design System documentation for installation guides, component usage, configuration, styling, tokens, patterns, and best practices. Use this for any question about how to use Mozaic.",
+    inputSchema: {
+        query: z
+            .string()
+            .describe("Search query (e.g., 'installation', 'vue setup', 'button props', 'color tokens')"),
+        limit: z.number().default(5).describe("Maximum number of results"),
+    },
+}, async (args) => {
+    log("Tool called: search_documentation", args);
+    if (!db)
+        db = initializeDatabase();
+    const result = handleSearchDocumentation(db, args);
+    log("Tool result: search_documentation", {
+        contentLength: result.content.length,
+        resultText: result.content[0]?.text?.substring(0, 500),
+    });
+    return result;
+});
+server.registerTool("get_css_utility", {
+    description: "Get CSS utility classes and examples for Mozaic layout and spacing utilities. These are CSS-only utilities (no framework component needed). Available: Flexy (flexbox grid), Container, Margin, Padding, Ratio, Scroll.",
+    inputSchema: {
+        name: z.string().describe("Utility name (e.g., 'flexy', 'margin', 'padding', 'container')"),
+        includeClasses: z
+            .boolean()
+            .default(true)
+            .describe("Include all CSS class names in the response"),
+    },
+}, async (args) => {
+    log("Tool called: get_css_utility", args);
+    if (!db)
+        db = initializeDatabase();
+    const result = handleGetCssUtility(db, args);
+    log("Tool result: get_css_utility", { contentLength: result.content.length });
+    return result;
+});
+server.registerTool("list_css_utilities", {
+    description: "List Mozaic CSS-only utilities (no framework needed). Returns utility names to use with get_css_utility. Layout: Flexy (grid), Container. Utility: Margin, Padding, Ratio, Scroll.",
+    inputSchema: {
+        category: z
+            .enum(["layout", "utility", "all"])
+            .default("all")
+            .describe("Filter: 'layout' (Flexy, Container) or 'utility' (Margin, Padding, Ratio, Scroll)"),
+    },
+}, async (args) => {
+    log("Tool called: list_css_utilities", args);
+    if (!db)
+        db = initializeDatabase();
+    const result = handleListCssUtilities(db, args);
+    log("Tool result: list_css_utilities", { contentLength: result.content.length });
+    return result;
+});
+server.registerTool("search_icons", {
+    description: "Search Mozaic Design System icons by name or type. Returns icon names, types (navigation, media, social, payment), and available sizes (16, 24, 32, 48, 64). Use get_icon for detailed SVG/code output.",
+    inputSchema: {
+        query: z
+            .string()
+            .describe('Search query for icon name (e.g., "arrow", "cart", "user", "check")'),
+        type: z
+            .string()
+            .optional()
+            .describe('Filter by icon type/category (e.g., "navigation", "media", "social")'),
+        size: z.number().optional().describe("Filter by icon size in pixels (16, 24, 32, 48, or 64)"),
+        limit: z.number().default(20).describe("Maximum number of results"),
+    },
+}, async (args) => {
+    log("Tool called: search_icons", args);
+    if (!db)
+        db = initializeDatabase();
+    const result = handleSearchIcons(db, args);
+    log("Tool result: search_icons", { contentLength: result.content.length });
+    return result;
+});
+server.registerTool("get_icon", {
+    description: "Get a specific Mozaic icon by name with SVG markup and ready-to-use code for React/Vue. Use search_icons first to find icon names.",
+    inputSchema: {
+        name: z.string().describe('The icon name (e.g., "ArrowArrowBottom16", "Cart24", "User32")'),
+        format: z
+            .enum(["svg", "react", "vue", "all"])
+            .default("all")
+            .describe("Output format: svg (raw SVG), react (import code), vue (component code), or all"),
+    },
+}, async (args) => {
+    log("Tool called: get_icon", args);
+    if (!db)
+        db = initializeDatabase();
+    const result = handleGetIcon(db, args);
+    log("Tool result: get_icon", { contentLength: result.content.length });
+    return result;
+});
+server.registerTool("get_install_info", {
+    description: "Get installation commands and import statements for a Mozaic component. Returns package name, install command (npm/yarn/pnpm), import statements, peer dependencies, and quick start code.",
+    inputSchema: {
+        component: z.string().describe('Component name (e.g., "button", "modal", "text-input")'),
+        framework: z
+            .enum(["vue", "react"])
+            .default("vue")
+            .describe("Target framework: vue (@mozaic-ds/vue-3) or react (@mozaic-ds/react)"),
+        packageManager: z
+            .enum(["npm", "yarn", "pnpm"])
+            .default("npm")
+            .describe("Package manager for install commands"),
+    },
+}, async (args) => {
+    log("Tool called: get_install_info", args);
+    if (!db)
+        db = initializeDatabase();
+    const result = handleGetInstallInfo(db, args);
+    log("Tool result: get_install_info", { contentLength: result.content.length });
+    return result;
+});
+// CLI helper functions
+function showVersion() {
+    const packageJson = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+    console.log(`mozaic-mcp-server v${packageJson.version}`);
+}
+function showHelp() {
+    console.log(`
+Mozaic MCP Server - Model Context Protocol server for Mozaic Design System
+
+USAGE:
+  mozaic-mcp-server [OPTIONS]
+
+OPTIONS:
+  --skills          Install skills to .claude/skills/ in current directory
+  --skills --force  Reinstall skills (overwrite existing files)
+  --list-skills     Show available skills without installing
+  --version         Show version number
+  --help            Show this help message
+  --debug           Enable debug logging to mcp-server.log
+
+EXAMPLES:
+  # Start MCP server (default)
+  mozaic-mcp-server
+
+  # Install skills locally
+  mozaic-mcp-server --skills
+
+  # Force reinstall skills
+  mozaic-mcp-server --skills --force
+
+  # List available skills
+  mozaic-mcp-server --list-skills
+
+For more information: https://github.com/MerzoukeMansouri/adeo-mozaic-mcp
+  `);
+}
+function listSkills() {
+    const skillsDir = join(__dirname, "..", "skills");
+    if (!existsSync(skillsDir)) {
+        console.log("❌ Skills directory not found. Ensure the package is properly installed.");
+        process.exit(1);
+    }
+    const skillFiles = readdirSync(skillsDir).filter((f) => f.endsWith(".md"));
+    console.log("\n📚 Available Mozaic Skills:\n");
+    for (const file of skillFiles) {
+        const skillPath = join(skillsDir, file);
+        const content = readFileSync(skillPath, "utf-8");
+        const titleMatch = content.match(/^# (.+)$/m);
+        const descMatch = content.match(/^This skill (.+)$/m);
+        const name = file.replace(".md", "");
+        const title = titleMatch ? titleMatch[1] : name;
+        const description = descMatch ? descMatch[1] : "No description available";
+        console.log(`  • ${title}`);
+        console.log(`    ${description}`);
+        console.log();
+    }
+    console.log(`To install: npx mozaic-mcp-server --skills\n`);
+}
+function installSkills(force = false) {
+    const cwd = process.cwd();
+    const targetDir = join(cwd, ".claude", "skills");
+    const skillsSourceDir = join(__dirname, "..", "skills");
+    // Check if source directory exists
+    if (!existsSync(skillsSourceDir)) {
+        console.log("❌ Skills directory not found in package.");
+        console.log("   This might be a development environment. Build the project first: pnpm build");
+        process.exit(1);
+    }
+    // Create target directory
+    if (!existsSync(targetDir)) {
+        mkdirSync(targetDir, { recursive: true });
+        console.log(`✅ Created directory: ${targetDir}`);
+    }
+    // Copy skill files
+    const skillFiles = readdirSync(skillsSourceDir).filter((f) => f.endsWith(".md"));
+    let installed = 0;
+    let skipped = 0;
+    let overwritten = 0;
+    console.log("\n📦 Installing Mozaic skills...\n");
+    for (const file of skillFiles) {
+        const source = join(skillsSourceDir, file);
+        const target = join(targetDir, file);
+        if (existsSync(target) && !force) {
+            console.log(`⚠️  Skipped ${file} (already exists, use --force to overwrite)`);
+            skipped++;
+        }
+        else {
+            const wasExisting = existsSync(target);
+            copyFileSync(source, target);
+            if (wasExisting && force) {
+                console.log(`♻️  Overwritten ${file}`);
+                overwritten++;
+            }
+            else {
+                console.log(`✅ Installed ${file}`);
+                installed++;
+            }
+        }
+    }
+    console.log(`\n🎉 Skill installation complete!`);
+    console.log(`   Installed: ${installed}`);
+    if (overwritten > 0)
+        console.log(`   Overwritten: ${overwritten}`);
+    if (skipped > 0)
+        console.log(`   Skipped: ${skipped}`);
+    console.log(`\n📂 Location: ${targetDir}`);
+    console.log(`\n💡 Usage in Claude Code:`);
+    console.log(`   • Skills are auto-detected in .claude/skills/`);
+    console.log(`   • Use them naturally in conversation`);
+    console.log(`   • Skills orchestrate Mozaic MCP tools automatically\n`);
+}
+// Parse CLI arguments
+const args = process.argv.slice(2);
+// Handle CLI commands
+if (args.includes("--help") || args.includes("-h")) {
+    showHelp();
+    process.exit(0);
+}
+if (args.includes("--version") || args.includes("-v")) {
+    showVersion();
+    process.exit(0);
+}
+if (args.includes("--list-skills")) {
+    listSkills();
+    process.exit(0);
+}
+if (args.includes("--skills")) {
+    const force = args.includes("--force") || args.includes("-f");
+    installSkills(force);
+    process.exit(0);
+}
+// Start server
+async function main() {
+    log("=== MCP Server Starting ===");
+    log("Debug mode enabled", { DEBUG, argv: process.argv });
+    log("Database path", { dbPath });
+    // Initialize database on startup
+    try {
+        db = initializeDatabase();
+    }
+    catch (error) {
+        log("Failed to initialize database on startup", { error: String(error) });
+        // Continue anyway - will fail gracefully on tool calls
+    }
+    log("Connecting to stdio transport");
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    log("Server connected and ready");
+}
+main().catch((error) => {
+    log("Fatal error", { error: String(error) });
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map