veryfront 0.1.142 → 0.1.144

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.142",
+  "version": "0.1.144",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "exclude": [

package/src/src/build/embedded/preset.ts

@@ -59,7 +59,7 @@ export async function buildEmbeddedPreset(
         adapter,
       });
 
-      await fs.mkdir(dirname(r.filePath), { recursive: true });
+      await fs.mkdir(presetDirname(r.filePath), { recursive: true });
       await fs.writeTextFile(r.filePath, compiled.code);
 
       const fileRel = r.filePath.slice(embeddedDir.length + 1).replace(/\\/g, "/");
@@ -93,7 +93,7 @@ export async function buildEmbeddedPreset(
         target: "es2020",
         format: "esm",
       });
-      const name = basename(srcPath).replace(/\.tsx?$/, ".js");
+      const name = presetBasename(srcPath).replace(/\.tsx?$/, ".js");
       await fs.writeTextFile(join(embeddedDir, "rsc", name), res.code);
     } catch (e) {
       logger.warn("embedded: failed to process RSC file", { error: String(e) } as unknown);
@@ -141,16 +141,35 @@ export async function buildEmbeddedPreset(
   return { manifest };
 }
 
-function dirname(path: string): string {
+/** @internal — exported for testing */
+export function presetDirname(path: string): string {
   const idx = path.lastIndexOf("/");
   return idx === -1 ? "" : path.slice(0, idx);
 }
 
-function basename(path: string): string {
+/** @internal — exported for testing */
+export function presetBasename(path: string): string {
   const idx = path.lastIndexOf("/");
   return idx === -1 ? path : path.slice(idx + 1);
 }
 
+/** @internal — exported for testing */
+export function normalizeAppRoutePath(rel: string): string {
+  return rel === "" ? "/" : rel.startsWith("/") ? rel : `/${rel}`;
+}
+
+/** @internal — exported for testing */
+export function normalizePageRoutePath(relPath: string): string {
+  const withoutExt = relPath.replace(/\.(mdx|md)$/, "");
+  const norm = `/${withoutExt}`;
+  return norm.replace(/\/+/g, "/") || "/";
+}
+
+/** @internal — exported for testing */
+export function isPageFile(name: string): boolean {
+  return (name.endsWith(".mdx") || name.endsWith(".md")) && !name.startsWith("_");
+}
+
 async function findOrCreateEntryPath(
   fs: ReturnType<typeof createFileSystem>,
   projectDir: string,
@@ -260,7 +279,7 @@ async function discoverAppRoutes(
       if (!ent.isFile || (ent.name !== "page.mdx" && ent.name !== "page.md")) continue;
 
       const routePath = rel.replace(/\/page\.(mdx|md)$/, "").replace(/(^$)/, "/");
-      const norm = routePath === "" ? "/" : routePath.startsWith("/") ? routePath : `/${routePath}`;
+      const norm = normalizeAppRoutePath(routePath);
 
       const filePath = join(embeddedDir, routePath === "" ? "app.js" : `app${norm}.js`);
       results.push({ routePath: norm, filePath, sourcePath: abs });
@@ -295,12 +314,9 @@ async function discoverPagesRoutes(
       }
 
       if (!ent.isFile) continue;
-      if (!ent.name.endsWith(".mdx") && !ent.name.endsWith(".md")) continue;
-      if (ent.name.startsWith("_")) continue;
+      if (!isPageFile(ent.name)) continue;
 
-      const withoutExt = relNext.replace(/\.(mdx|md)$/, "");
-      const norm = `/${withoutExt}`;
-      const routePath = norm.replace(/\/+/g, "/") ? norm.replace(/\/+/g, "/") : "/";
+      const routePath = normalizePageRoutePath(relNext);
       const filePath = join(embeddedDir, `pages${routePath}.js`.replace(/\/+/g, "/"));
       results.push({ routePath, filePath, sourcePath: abs });
     }

package/src/src/mcp/server.ts

@@ -159,21 +159,25 @@ export class MCPServer {
   ): Promise<unknown> {
     switch (method) {
       case "tools/list":
-        return this.listTools();
+        return this.listTools(params);
       case "tools/call":
         return this.callTool(params, context);
       case "resources/list":
-        return this.listResources();
+        return this.listResources(params);
       case "resources/read":
         return this.readResource(params);
+      case "resources/templates/list":
+        return this.listResourceTemplates(params);
       case "prompts/list":
-        return this.listPrompts();
+        return this.listPrompts(params);
       case "prompts/get":
         return this.getPrompt(params);
       case "initialize":
         return this.initialize(params);
       case "notifications/initialized":
         return Promise.resolve({});
+      case "completion/complete":
+        return this.complete(params);
       default:
         throw toError(
           createError({
@@ -204,13 +208,14 @@ export class MCPServer {
         tools: { listChanged: true },
         resources: { subscribe: true, listChanged: true },
         prompts: { listChanged: true },
+        completions: {},
       },
       instructions:
         "Veryfront MCP server provides development tools. Use vf_get_errors to check for code errors, vf_get_logs for server logs, vf_scaffold for code generation, and vf_get_project_context for project structure.",
     });
   }
 
-  private async listTools(): Promise<{ tools: ToolListEntry[] }> {
+  private async listTools(_params?: JSONRPCParams): Promise<{ tools: ToolListEntry[] }> {
     // Sync integration config to API on first tools/list call
     if (this.integrationLoader && !this.integrationsLoaded) {
       try {
@@ -287,17 +292,44 @@ export class MCPServer {
     );
   }
 
-  private listResources(): Promise<{ resources: Array<Record<string, unknown>> }> {
+  private listResourceTemplates(
+    _params?: JSONRPCParams,
+  ): Promise<{ resourceTemplates: Array<Record<string, unknown>> }> {
+    const registry = getMCPRegistry();
+    const templates: Array<Record<string, unknown>> = [];
+
+    for (const [id, resource] of registry.resources.entries()) {
+      if (/:(\w+)/.test(resource.pattern)) {
+        const uriTemplate = resource.pattern.replace(/:(\w+)/g, "{$1}");
+        const entry: Record<string, unknown> = {
+          uriTemplate,
+          name: id,
+          description: resource.description,
+          mimeType: "application/json",
+        };
+        if (resource.title) entry.title = resource.title;
+        templates.push(entry);
+      }
+    }
+
+    return Promise.resolve({ resourceTemplates: templates });
+  }
+
+  private listResources(
+    _params?: JSONRPCParams,
+  ): Promise<{ resources: Array<Record<string, unknown>> }> {
     const registry = getMCPRegistry();
     const resources: Array<Record<string, unknown>> = [];
 
     for (const [id, resource] of registry.resources.entries()) {
-      resources.push({
+      const entry: Record<string, unknown> = {
         uri: resource.pattern,
         name: id,
         description: resource.description,
         mimeType: "application/json",
-      });
+      };
+      if (resource.title) entry.title = resource.title;
+      resources.push(entry);
     }
 
     return Promise.resolve({ resources });
@@ -348,7 +380,9 @@ export class MCPServer {
     );
   }
 
-  private listPrompts(): Promise<{ prompts: Array<Record<string, unknown>> }> {
+  private listPrompts(
+    _params?: JSONRPCParams,
+  ): Promise<{ prompts: Array<Record<string, unknown>> }> {
     const registry = getMCPRegistry();
     const prompts: Array<Record<string, unknown>> = [];
 
@@ -401,6 +435,16 @@ export class MCPServer {
     );
   }
 
+  private complete(
+    _params: JSONRPCParams | undefined,
+  ): Promise<{ completion: { values: string[]; total?: number; hasMore: boolean } }> {
+    // Stub: returns empty completions for all refs.
+    // Real logic will resolve values from resource templates and prompts.
+    return Promise.resolve({
+      completion: { values: [], total: 0, hasMore: false },
+    });
+  }
+
   createHTTPHandler(): (request: dntShim.Request) => Promise<dntShim.Response> {
     return async (request: dntShim.Request) => {
       const requestOrigin = request.headers.get("Origin");

package/src/src/resource/factory.ts

@@ -19,6 +19,7 @@ export function resource<TParams = unknown, TData = unknown>(
     id,
     pattern,
     description: config.description,
+    title: config.title,
     paramsSchema: config.paramsSchema,
     load: async (params: TParams): Promise<TData> => {
       try {

package/src/src/resource/types.ts

@@ -17,6 +17,7 @@ import type { McpConfig } from "./schemas/index.js";
 export interface ResourceConfig<TParams = unknown, TData = unknown> {
   pattern?: string;
   description: string;
+  title?: string;
   paramsSchema: z.ZodSchema<TParams>;
   load: (params: TParams) => Promise<TData> | TData;
   subscribe?: (params: TParams) => AsyncIterable<TData>;
@@ -27,6 +28,7 @@ export interface Resource<TParams = unknown, TData = unknown> {
   id: string;
   pattern: string;
   description: string;
+  title?: string;
   paramsSchema: z.ZodSchema<TParams>;
   load: (params: TParams) => Promise<TData>;
   subscribe?: (params: TParams) => AsyncIterable<TData>;