@jrmc/adonis-mcp 1.0.0-alpha.9 → 1.0.0-beta.2

package/build/src/utils/uri_template.d.ts

@@ -0,0 +1,25 @@
+export type Variables = Record<string, string | string[]>;
+export declare class UriTemplate {
+    /**
+     * Returns true if the given string contains any URI template expressions.
+     * A template expression is a sequence of characters enclosed in curly braces,
+     * like {foo} or {?bar}.
+     */
+    static isTemplate(str: string): boolean;
+    private static validateLength;
+    private readonly template;
+    private readonly parts;
+    get variableNames(): string[];
+    constructor(template: string);
+    toString(): string;
+    private parse;
+    private getOperator;
+    private getNames;
+    private encodeValue;
+    private expandPart;
+    expand(variables: Variables): string;
+    private escapeRegExp;
+    private partToRegExp;
+    match(uri: string): Variables | null;
+}
+//# sourceMappingURL=uri_template.d.ts.map

package/build/src/utils/uri_template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uri_template.d.ts","sourceRoot":"","sources":["../../../src/utils/uri_template.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAA;AASzD,qBAAa,WAAW;IACtB;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAMvC,OAAO,CAAC,MAAM,CAAC,cAAc;IAQ7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAErB;IAED,IAAI,aAAa,IAAI,MAAM,EAAE,CAE5B;gBAEW,QAAQ,EAAE,MAAM;IAM5B,QAAQ,IAAI,MAAM;IAIlB,OAAO,CAAC,KAAK;IAsDb,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,UAAU;IAsDlB,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM;IA4BpC,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,YAAY;IAkDpB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;CAuCrC"}

package/build/src/utils/uri_template.js

@@ -0,0 +1,241 @@
+// Claude-authored implementation of RFC 6570 URI Templates
+import { createError } from '@adonisjs/core/exceptions';
+const MAX_TEMPLATE_LENGTH = 1000000; // 1MB
+const MAX_VARIABLE_LENGTH = 1000000; // 1MB
+const MAX_TEMPLATE_EXPRESSIONS = 10000;
+const MAX_REGEX_LENGTH = 1000000; // 1MB
+export class UriTemplate {
+    /**
+     * Returns true if the given string contains any URI template expressions.
+     * A template expression is a sequence of characters enclosed in curly braces,
+     * like {foo} or {?bar}.
+     */
+    static isTemplate(str) {
+        // Look for any sequence of characters between curly braces
+        // that isn't just whitespace
+        return /\{[^}\s]+\}/.test(str);
+    }
+    static validateLength(str, max, context) {
+        if (str.length > max) {
+            throw createError(`${context} exceeds maximum length of ${max} characters (got ${str.length})`, 'E_URI_TEMPLATE_LENGTH_EXCEEDED');
+        }
+    }
+    template;
+    parts;
+    get variableNames() {
+        return this.parts.flatMap((part) => (typeof part === 'string' ? [] : part.names));
+    }
+    constructor(template) {
+        UriTemplate.validateLength(template, MAX_TEMPLATE_LENGTH, 'Template');
+        this.template = template;
+        this.parts = this.parse(template);
+    }
+    toString() {
+        return this.template;
+    }
+    parse(template) {
+        const parts = [];
+        let currentText = '';
+        let i = 0;
+        let expressionCount = 0;
+        while (i < template.length) {
+            if (template[i] === '{') {
+                if (currentText) {
+                    parts.push(currentText);
+                    currentText = '';
+                }
+                const end = template.indexOf('}', i);
+                if (end === -1)
+                    throw createError('Unclosed template expression', 'E_URI_TEMPLATE_UNCLOSED_EXPRESSION');
+                expressionCount++;
+                if (expressionCount > MAX_TEMPLATE_EXPRESSIONS) {
+                    throw createError(`Template contains too many expressions (max ${MAX_TEMPLATE_EXPRESSIONS})`, 'E_URI_TEMPLATE_TOO_MANY_EXPRESSIONS');
+                }
+                const expr = template.slice(i + 1, end);
+                const operator = this.getOperator(expr);
+                const exploded = expr.includes('*');
+                const names = this.getNames(expr);
+                const name = names[0];
+                // Validate variable name length
+                for (const name of names) {
+                    UriTemplate.validateLength(name, MAX_VARIABLE_LENGTH, 'Variable name');
+                }
+                parts.push({ name, operator, names, exploded });
+                i = end + 1;
+            }
+            else {
+                currentText += template[i];
+                i++;
+            }
+        }
+        if (currentText) {
+            parts.push(currentText);
+        }
+        return parts;
+    }
+    getOperator(expr) {
+        const operators = ['+', '#', '.', '/', '?', '&'];
+        return operators.find((op) => expr.startsWith(op)) || '';
+    }
+    getNames(expr) {
+        const operator = this.getOperator(expr);
+        return expr
+            .slice(operator.length)
+            .split(',')
+            .map((name) => name.replace('*', '').trim())
+            .filter((name) => name.length > 0);
+    }
+    encodeValue(value, operator) {
+        UriTemplate.validateLength(value, MAX_VARIABLE_LENGTH, 'Variable value');
+        if (operator === '+' || operator === '#') {
+            return encodeURI(value);
+        }
+        return encodeURIComponent(value);
+    }
+    expandPart(part, variables) {
+        if (part.operator === '?' || part.operator === '&') {
+            const pairs = part.names
+                .map((name) => {
+                const value = variables[name];
+                if (value === undefined)
+                    return '';
+                const encoded = Array.isArray(value)
+                    ? value.map((v) => this.encodeValue(v, part.operator)).join(',')
+                    : this.encodeValue(value.toString(), part.operator);
+                return `${name}=${encoded}`;
+            })
+                .filter((pair) => pair.length > 0);
+            if (pairs.length === 0)
+                return '';
+            const separator = part.operator === '?' ? '?' : '&';
+            return separator + pairs.join('&');
+        }
+        if (part.names.length > 1) {
+            const values = part.names.map((name) => variables[name]).filter((v) => v !== undefined);
+            if (values.length === 0)
+                return '';
+            return values.map((v) => (Array.isArray(v) ? v[0] : v)).join(',');
+        }
+        const value = variables[part.name];
+        if (value === undefined)
+            return '';
+        const values = Array.isArray(value) ? value : [value];
+        const encoded = values.map((v) => this.encodeValue(v, part.operator));
+        switch (part.operator) {
+            case '':
+                return encoded.join(',');
+            case '+':
+                return encoded.join(',');
+            case '#':
+                return '#' + encoded.join(',');
+            case '.':
+                return '.' + encoded.join('.');
+            case '/':
+                return '/' + encoded.join('/');
+            default:
+                return encoded.join(',');
+        }
+    }
+    expand(variables) {
+        let result = '';
+        let hasQueryParam = false;
+        for (const part of this.parts) {
+            if (typeof part === 'string') {
+                result += part;
+                continue;
+            }
+            const expanded = this.expandPart(part, variables);
+            if (!expanded)
+                continue;
+            // Convert ? to & if we already have a query parameter
+            if ((part.operator === '?' || part.operator === '&') && hasQueryParam) {
+                result += expanded.replace('?', '&');
+            }
+            else {
+                result += expanded;
+            }
+            if (part.operator === '?' || part.operator === '&') {
+                hasQueryParam = true;
+            }
+        }
+        return result;
+    }
+    escapeRegExp(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    partToRegExp(part) {
+        const patterns = [];
+        // Validate variable name length for matching
+        for (const name of part.names) {
+            UriTemplate.validateLength(name, MAX_VARIABLE_LENGTH, 'Variable name');
+        }
+        if (part.operator === '?' || part.operator === '&') {
+            for (let i = 0; i < part.names.length; i++) {
+                const name = part.names[i];
+                const prefix = i === 0 ? '\\' + part.operator : '&';
+                patterns.push({
+                    pattern: prefix + this.escapeRegExp(name) + '=([^&]+)',
+                    name,
+                });
+            }
+            return patterns;
+        }
+        let pattern;
+        const name = part.name;
+        switch (part.operator) {
+            case '':
+                pattern = part.exploded ? '([^/]+(?:,[^/]+)*)' : '([^/,]+)';
+                break;
+            case '+':
+            case '#':
+                pattern = '(.+)';
+                break;
+            case '.':
+                pattern = '\\.([^/,]+)';
+                break;
+            case '/':
+                pattern = '/' + (part.exploded ? '([^/]+(?:,[^/]+)*)' : '([^/,]+)');
+                break;
+            default:
+                pattern = '([^/]+)';
+        }
+        patterns.push({ pattern, name });
+        return patterns;
+    }
+    match(uri) {
+        UriTemplate.validateLength(uri, MAX_TEMPLATE_LENGTH, 'URI');
+        let pattern = '^';
+        const names = [];
+        for (const part of this.parts) {
+            if (typeof part === 'string') {
+                pattern += this.escapeRegExp(part);
+            }
+            else {
+                const patterns = this.partToRegExp(part);
+                for (const { pattern: partPattern, name } of patterns) {
+                    pattern += partPattern;
+                    names.push({ name, exploded: part.exploded });
+                }
+            }
+        }
+        pattern += '$';
+        UriTemplate.validateLength(pattern, MAX_REGEX_LENGTH, 'Generated regex pattern');
+        const regex = new RegExp(pattern);
+        const match = uri.match(regex);
+        if (!match)
+            return null;
+        const result = {};
+        for (let i = 0; i < names.length; i++) {
+            const { name, exploded } = names[i];
+            const value = match[i + 1];
+            const cleanName = name.replace('*', '');
+            if (exploded && value.includes(',')) {
+                result[cleanName] = value.split(',');
+            }
+            else {
+                result[cleanName] = value;
+            }
+        }
+        return result;
+    }
+}

package/build/stubs/config.ts.stub

@@ -6,5 +6,4 @@ import { defineConfig } from '@jrmc/adonis-mcp'
 export default defineConfig({
   name: 'adonis-mcp-server',
   version: '1.0.0',
-  path: 'app/mcp',
 })

package/build/stubs/make/mcp/prompts/main.ts.stub

@@ -1,27 +1,43 @@
+{{#var className = `${name}Prompt`}}
+{{#var promptName = string(name).snakeCase()}}
 {{#var resourceFileName = string(className).snakeCase().ext('.ts').toString()}}
 {{{
   exports({
-    to: app.makePath(app.rcFile.directories['mcp'] || 'app/mcp/', 'prompts', resourceFileName)
+    to: app.makePath(app.rcFile.directories['mcp'] || 'app/mcp/', `prompts/`, resourceFileName)
   })
 }}}
-import type { Prompt } from '@jrmc/adonis-mcp/types'
+import type { PromptContext } from '@jrmc/adonis-mcp/types/context'
+import type { BaseSchema } from '@jrmc/adonis-mcp/types/method'
 
-export default class {{ className }} implements Prompt {
-  name = 'prompt_name'
-  config = {
-    title: 'Prompt Title',
-    description: 'Prompt Description',
-    argsSchema: {}
+import { Prompt } from '@jrmc/adonis-mcp'
+
+type Schema = BaseSchema<{
+  text: { type: "string" }
+}>
+
+
+export default class {{ className }} extends Prompt<Schema> {
+  name = '{{ promptName }}'
+  title = 'Prompt title'
+  description = 'Prompt description'
+
+  async handle({ args, response }: PromptContext<Schema>) {
+    console.log(args?.text)
+    return [
+      response.text('Hello, world!')
+    ]
   }
 
-  async handle() {
+  schema() {
     return {
-      messages: [
-        {
-          role: 'user' as const,
-          content: { type: 'text' as const, text: `Please review this code:\n\n${code}` }
-        }
-      ]
-    }
+      type: "object",
+      properties: {
+        text: {
+          type: "string",
+          description: "Description text argument"
+        },
+      },
+      required: ["text"]
+    } as Schema
   }
 }

package/build/stubs/make/mcp/resources/main.ts.stub

@@ -1,29 +1,23 @@
+{{#var className = `${name}Resource`}}
 {{#var resourceFileName = string(className).snakeCase().ext('.ts').toString()}}
 {{{
   exports({
-    to: app.makePath(app.rcFile.directories['mcp'] || 'app/mcp/', 'resources', resourceFileName)
+    to: app.makePath(app.rcFile.directories['mcp'] || 'app/mcp/', `resources/`, resourceFileName)
   })
 }}}
-import { type Resource, ResourceTemplate, Response } from '@jrmc/adonis-mcp/types'
+import type { ResourceContext } from '@jrmc/adonis-mcp/types/context'
 
-export default class {{ className }} implements Resource {
-  name = 'resource_name'
-  config = {
-    title: 'Resoource title',
-    description: 'Resource description'
-  }
+import { Resource } from '@jrmc/adonis-mcp'
+
+export default class {{ className }} extends Resource {
+  name = 'example.txt'
+  uri = 'file:///example.txt'
+  mimeType = 'text/plain"'
 
-  uriOrTemplate = new ResourceTemplate('users://{userId}/profile', { list: undefined })
+  title = 'ToResource title'
+  description = 'Resource description'
 
-  async handle(uri: URL, { userId }: { userId: string }) {
-    return Response.uri(uri, `Profile data for user ${userId}`)
-    // return {
-    //   contents: [
-    //     {
-    //       uri: uri.href,
-    //       text: `Profile data for user ${userId}`
-    //     }
-    //   ]
-    // }
+  async handle({ response }: ResourceContext) {
+    return response.text('Hello World')
   }
 }

package/build/stubs/make/mcp/tools/main.ts.stub

@@ -1,41 +1,39 @@
 {{#var className = `${name}Tool`}}
+{{#var toolName = string(name).snakeCase()}}
 {{#var resourceFileName = string(className).snakeCase().ext('.ts').toString()}}
 {{{
   exports({
-    to: app.makePath(app.rcFile.directories['mcp'] || basePath, resourceFileName)
+    to: app.makePath(app.rcFile.directories['mcp'] || 'app/mcp/', `tools/`, resourceFileName)
   })
 }}}
-import type { McpContext } from '@jrmc/adonis-mcp/types/context'
-import type { BaseSchema, InferJSONSchema } from '@jrmc/adonis-mcp/types/method'
+import type { ToolContext } from '@jrmc/adonis-mcp/types/context'
+import type { BaseSchema } from '@jrmc/adonis-mcp/types/method'
 
 import { Tool } from '@jrmc/adonis-mcp'
 
 type Schema = BaseSchema<{
-  text: { type: "string" }
+  name: { type: "string" }
 }>
 
-type Context = McpContext & { args: InferJSONSchema<Schema> }
-
-export default class {{ className }} implements Tool<Schema> {
-  name = '{{ name }}'
+export default class {{ className }} extends Tool<Schema> {
+  name = '{{ toolName }}'
   title = 'Tool title'
   description = 'Tool description'
 
-  async handle({ args, response }: Context) {
-    console.log(args.text)
-    return response.text(JSON.stringify({ text: 'Hello, world!' }))
+  async handle({ args, response }: ToolContext<Schema>) {
+    return response.text({{ "`Hello, ${args?.name}`" }})
   }
 
   schema() {
     return {
       type: "object",
       properties: {
-        text: {
+        name: {
           type: "string",
           description: "Description text argument"
         },
       },
-      required: ["text"]
+      required: ["name"]
     } as Schema
   }
 }

package/build/stubs/make/middleware/mcp_middleware.ts.stub

@@ -0,0 +1,48 @@
+{{{
+  exports({ to: app.middlewarePath('mcp_middleware.ts') })
+}}}
+import type { HttpContext } from '@adonisjs/core/http'
+import type { NextFn } from '@adonisjs/core/types/http'
+
+// import { policies } from '#policies/main'
+// import * as abilities from '#abilities/main'
+// import { Bouncer } from '@adonisjs/bouncer'
+
+export default class McpMiddleware {
+  async handle(ctx: HttpContext, next: NextFn) {
+    const body = ctx.request.body()
+    const method = body.method
+
+    const contentType = ctx.request.header('Content-Type')
+    if (!contentType || !['application/json', 'text/event-stream'].includes(contentType)) {
+      return ctx.response.badRequest('Content-Type header must be application/json')
+    }
+
+    if (method === 'initialize') {
+      ctx.response.safeHeader('MCP-Session-Id', crypto.randomUUID())
+    } else {
+      const sessionId = ctx.request.header('MCP-Session-Id')
+
+      if (!sessionId) {
+        return ctx.response.badRequest('MCP-Session-Id header is required')
+      }
+
+      ctx.response.safeHeader('MCP-Session-Id', sessionId)
+    }
+
+    return next()
+  }
+}
+
+// declare module '@jrmc/adonis-mcp/types/context' {
+//   export interface McpContext {
+//     auth?: {
+//       user?: HttpContext['auth']['user']
+//     }
+//     bouncer?: Bouncer<
+//       Exclude<HttpContext['auth']['user'], undefined>,
+//       typeof abilities,
+//       typeof policies
+//     >
+//   }
+// }