@omnitend/dashboard-for-laravel 0.4.7

package/resources/js/utils/api.ts

@@ -0,0 +1,182 @@
+export interface ApiError {
+    message: string;
+    errors: Record<string, string[]>;
+    status: number;
+}
+
+export interface ApiResponse<T = unknown> {
+    data: T;
+    response: Response;
+}
+
+interface RequestOptions extends Omit<RequestInit, "body"> {
+    headers?: Record<string, string>;
+    body?: BodyInit | null; // allow FormData/Blob/etc.
+}
+
+class ApiClient {
+    private baseURL = "";
+    private defaultHeaders: Record<string, string> = {
+        Accept: "application/json",
+        "Content-Type": "application/json", // removed automatically for FormData
+        "X-Requested-With": "XMLHttpRequest",
+    };
+
+    setBaseURL(url: string) {
+        this.baseURL = url.replace(/\/+$/, "");
+    }
+    setDefaultHeader(key: string, value: string) {
+        this.defaultHeaders[key] = value;
+    }
+
+    private getCsrfToken(): string {
+        if (typeof document === 'undefined') {
+            return "";
+        }
+        const el = document.querySelector('meta[name="csrf-token"]');
+        return el?.getAttribute("content") ?? "";
+    }
+
+    private toQuery(params: Record<string, unknown> = {}): string {
+        const search = new URLSearchParams();
+        const append = (k: string, v: unknown) => {
+            if (v === undefined || v === null) return;
+            if (Array.isArray(v)) v.forEach((x) => append(`${k}[]`, x));
+            else if (typeof v === "object") {
+                for (const [ck, cv] of Object.entries(
+                    v as Record<string, unknown>,
+                )) {
+                    append(`${k}[${ck}]`, cv);
+                }
+            } else {
+                search.append(k, String(v));
+            }
+        };
+        for (const [k, v] of Object.entries(params)) append(k, v);
+        const qs = search.toString();
+        return qs ? `?${qs}` : "";
+    }
+
+    private handleError(response: Response, data: any): never {
+        const error: ApiError = {
+            message: data?.message ?? "An error occurred",
+            errors: (data?.errors as Record<string, string[]>) ?? {},
+            status: response.status,
+        };
+        switch (response.status) {
+            case 422:
+                error.message = data?.message ?? "Validation failed";
+                break;
+            case 401:
+                error.message = "Unauthenticated. Please log in.";
+                break;
+            case 403:
+                error.message = "Forbidden. You do not have permission.";
+                break;
+            case 404:
+                error.message = "Resource not found.";
+                break;
+            case 419:
+                error.message = "Page expired. Please refresh and try again.";
+                break;
+            case 500:
+                error.message = "Server error. Please try again later.";
+                break;
+        }
+        throw error;
+    }
+
+    async request<T = unknown>(
+        url: string,
+        options: RequestOptions = {},
+    ): Promise<ApiResponse<T>> {
+        const isFormData =
+            typeof FormData !== "undefined" && options.body instanceof FormData;
+
+        const headers: Record<string, string> = {
+            ...this.defaultHeaders,
+            ...(isFormData
+                ? {}
+                : { "Content-Type": this.defaultHeaders["Content-Type"] }),
+            "X-CSRF-TOKEN": this.getCsrfToken(),
+            ...options.headers,
+        };
+
+        // Let fetch set the multipart boundary if FormData
+        if (isFormData) delete headers["Content-Type"];
+
+        const config: RequestOptions = {
+            credentials: "same-origin",
+            ...options,
+            headers,
+        };
+
+        const resp = await fetch(this.baseURL + url, config);
+
+        // Fast-path for 204/205
+        if (resp.status === 204 || resp.status === 205) {
+            if (!resp.ok) {
+                this.handleError(resp, null);
+            }
+
+            return { data: undefined as unknown as T, response: resp };
+        }
+
+        const ctype = resp.headers.get("Content-Type") || "";
+        const isJson = /\bjson\b/i.test(ctype);
+        const parsed = isJson
+            ? await resp.json().catch(() => ({}))
+            : await resp.text();
+
+        if (!resp.ok) {
+            this.handleError(resp, parsed);
+        }
+
+        return { data: parsed as T, response: resp };
+    }
+
+    async get<T = unknown>(
+        url: string,
+        params: Record<string, unknown> = {},
+        options: Omit<RequestOptions, "method"> = {},
+    ) {
+        const full = `${url}${this.toQuery(params)}`;
+        return this.request<T>(full, { ...options, method: "GET" });
+    }
+
+    async post<T = unknown>(
+        url: string,
+        data: any = {},
+        options: Omit<RequestOptions, "method" | "body"> = {},
+    ) {
+        const body = data instanceof FormData ? data : JSON.stringify(data);
+        return this.request<T>(url, { ...options, method: "POST", body });
+    }
+
+    async put<T = unknown>(
+        url: string,
+        data: any = {},
+        options: Omit<RequestOptions, "method" | "body"> = {},
+    ) {
+        const body = data instanceof FormData ? data : JSON.stringify(data);
+        return this.request<T>(url, { ...options, method: "PUT", body });
+    }
+
+    async patch<T = unknown>(
+        url: string,
+        data: any = {},
+        options: Omit<RequestOptions, "method" | "body"> = {},
+    ) {
+        const body = data instanceof FormData ? data : JSON.stringify(data);
+        return this.request<T>(url, { ...options, method: "PATCH", body });
+    }
+
+    async delete<T = unknown>(
+        url: string,
+        options: Omit<RequestOptions, "method"> = {},
+    ) {
+        return this.request<T>(url, { ...options, method: "DELETE" });
+    }
+}
+
+export const api = new ApiClient();

package/scripts/mcp-server.mjs

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+
+/**
+ * MCP Server for Dashboard for Laravel Documentation
+ *
+ * Provides AI agents with structured access to documentation via MCP tools.
+ * Works with Claude Desktop, Claude Code, and any MCP-compatible client.
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { readFileSync, readdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = join(__dirname, '..');
+
+// Load generated documentation files
+function loadApiReference() {
+  const path = join(rootDir, 'docs/public/api-reference.json');
+  if (!existsSync(path)) {
+    throw new Error('API reference not found. Run: npm run docs:generate:ai');
+  }
+  return JSON.parse(readFileSync(path, 'utf8'));
+}
+
+function loadDocsMap() {
+  const path = join(rootDir, 'docs/public/docs-map.md');
+  if (!existsSync(path)) {
+    throw new Error('Docs map not found. Run: npm run docs:generate:ai');
+  }
+  return readFileSync(path, 'utf8');
+}
+
+function loadLlmsTxt() {
+  const path = join(rootDir, 'docs/public/llms.txt');
+  if (!existsSync(path)) {
+    throw new Error('llms.txt not found. Run: npm run docs:generate:ai');
+  }
+  return readFileSync(path, 'utf8');
+}
+
+// Read guide/documentation files
+function readGuide(slug) {
+  const guidePath = join(rootDir, `docs/src/pages/guide/${slug}.md`);
+  if (!existsSync(guidePath)) {
+    return null;
+  }
+  return readFileSync(guidePath, 'utf8');
+}
+
+// Create MCP server
+const server = new Server(
+  {
+    name: 'dashboard-for-laravel-docs',
+    version: '0.3.1',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: 'list_components',
+        description: 'List all components, optionally filtered by category (base/extended) or tag',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            category: {
+              type: 'string',
+              enum: ['base', 'extended'],
+              description: 'Filter by component category',
+            },
+            tag: {
+              type: 'string',
+              description: 'Filter by tag (e.g., forms, tables, navigation)',
+            },
+          },
+        },
+      },
+      {
+        name: 'get_component',
+        description: 'Get detailed API information for a specific component (props, events, slots)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: {
+              type: 'string',
+              description: 'Component name (e.g., DButton, DXTable)',
+            },
+          },
+          required: ['name'],
+        },
+      },
+      {
+        name: 'search_components',
+        description: 'Search components by name or description',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: {
+              type: 'string',
+              description: 'Search query',
+            },
+          },
+          required: ['query'],
+        },
+      },
+      {
+        name: 'get_guide',
+        description: 'Get a documentation guide (installation, forms, theming, typescript, getting-started)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            slug: {
+              type: 'string',
+              enum: ['installation', 'forms', 'theming', 'typescript', 'getting-started'],
+              description: 'Guide slug',
+            },
+          },
+          required: ['slug'],
+        },
+      },
+      {
+        name: 'get_overview',
+        description: 'Get complete documentation overview (llms.txt content)',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+        },
+      },
+      {
+        name: 'get_docs_map',
+        description: 'Get hierarchical map of all available documentation',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+        },
+      },
+    ],
+  };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case 'list_components': {
+        const apiRef = loadApiReference();
+        let components = [
+          ...apiRef.components.base.map(c => ({ ...c, category: 'base' })),
+          ...apiRef.components.extended.map(c => ({ ...c, category: 'extended' })),
+        ];
+
+        // Filter by category
+        if (args.category) {
+          components = components.filter(c => c.category === args.category);
+        }
+
+        // Filter by tag (from frontmatter)
+        if (args.tag) {
+          const tag = args.tag.toLowerCase();
+          components = components.filter(c => {
+            const mdxPath = join(rootDir, `docs/src/pages/components/${c.category}/${c.name}.mdx`);
+            if (!existsSync(mdxPath)) return false;
+            const content = readFileSync(mdxPath, 'utf8');
+            const tagsMatch = content.match(/^tags:\s*(.+)$/m);
+            if (!tagsMatch) return false;
+            return tagsMatch[1].toLowerCase().includes(tag);
+          });
+        }
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(
+                {
+                  total: components.length,
+                  components: components.map(c => ({
+                    name: c.name,
+                    category: c.category,
+                    description: c.description,
+                    propsCount: c.props.length,
+                    eventsCount: c.events.length,
+                    slotsCount: c.slots.length,
+                  })),
+                },
+                null,
+                2
+              ),
+            },
+          ],
+        };
+      }
+
+      case 'get_component': {
+        const apiRef = loadApiReference();
+        const allComponents = [
+          ...apiRef.components.base,
+          ...apiRef.components.extended,
+        ];
+        const component = allComponents.find(c => c.name === args.name);
+
+        if (!component) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `Component "${args.name}" not found. Available components: ${allComponents.map(c => c.name).join(', ')}`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(component, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'search_components': {
+        const apiRef = loadApiReference();
+        const allComponents = [
+          ...apiRef.components.base,
+          ...apiRef.components.extended,
+        ];
+        const query = args.query.toLowerCase();
+
+        const matches = allComponents.filter(c =>
+          c.name.toLowerCase().includes(query) ||
+          c.description.toLowerCase().includes(query) ||
+          c.filePath.toLowerCase().includes(query)
+        );
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(
+                {
+                  query: args.query,
+                  matches: matches.length,
+                  components: matches.map(c => ({
+                    name: c.name,
+                    category: c.category,
+                    description: c.description,
+                    filePath: c.filePath,
+                  })),
+                },
+                null,
+                2
+              ),
+            },
+          ],
+        };
+      }
+
+      case 'get_guide': {
+        const content = readGuide(args.slug);
+        if (!content) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `Guide "${args.slug}" not found.`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: content,
+            },
+          ],
+        };
+      }
+
+      case 'get_overview': {
+        const llmsTxt = loadLlmsTxt();
+        return {
+          content: [
+            {
+              type: 'text',
+              text: llmsTxt,
+            },
+          ],
+        };
+      }
+
+      case 'get_docs_map': {
+        const docsMap = loadDocsMap();
+        return {
+          content: [
+            {
+              type: 'text',
+              text: docsMap,
+            },
+          ],
+        };
+      }
+
+      default:
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Unknown tool: ${name}`,
+            },
+          ],
+          isError: true,
+        };
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error: ${error.message}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('Dashboard for Laravel MCP Server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Server error:', error);
+  process.exit(1);
+});