@kinqs/brainrouter-mcp-server 0.3.4

package/dist/tools/create_skill.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import type { Registry } from '../registry.js';
+export declare const createSkillSchema: z.ZodObject<{
+    name: z.ZodString;
+    category: z.ZodString;
+    description: z.ZodString;
+    overview: z.ZodOptional<z.ZodString>;
+    when_to_use: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    usage: z.ZodOptional<z.ZodString>;
+    checklist: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    scope: z.ZodDefault<z.ZodOptional<z.ZodEnum<["global", "local"]>>>;
+    project: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    name: string;
+    category: string;
+    scope: "global" | "local";
+    overview?: string | undefined;
+    when_to_use?: string | undefined;
+    workflow?: string[] | undefined;
+    usage?: string | undefined;
+    checklist?: string[] | undefined;
+    project?: string | undefined;
+}, {
+    description: string;
+    name: string;
+    category: string;
+    overview?: string | undefined;
+    when_to_use?: string | undefined;
+    workflow?: string[] | undefined;
+    usage?: string | undefined;
+    checklist?: string[] | undefined;
+    project?: string | undefined;
+    scope?: "global" | "local" | undefined;
+}>;
+export declare function createSkill(registry: Registry, args: z.infer<typeof createSkillSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    metadata: {
+        scope: "global" | "local";
+        project: string | undefined;
+    };
+}>;

package/dist/tools/create_skill.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { scaffoldSkill } from '../writer.js';
+export const createSkillSchema = z.object({
+    name: z.string(),
+    category: z.string(),
+    description: z.string(),
+    overview: z.string().optional(),
+    when_to_use: z.string().optional(),
+    workflow: z.array(z.string()).optional(),
+    usage: z.string().optional(),
+    checklist: z.array(z.string()).optional(),
+    scope: z.enum(['global', 'local']).optional().default('local'),
+    project: z.string().optional(),
+});
+export async function createSkill(registry, args) {
+    const localRoot = registry.getLocalRoot();
+    const globalRoot = registry.getGlobalRoot();
+    const localProjectName = registry.getLocalProjectName();
+    const targetRoot = args.scope === 'global' ? globalRoot : localRoot;
+    if (!targetRoot) {
+        throw new Error(`No ${args.scope} root detected.`);
+    }
+    // Check if skill exists
+    if (registry.getSkill(args.name)) {
+        throw new Error(`Skill "${args.name}" already exists.`);
+    }
+    const project = args.project || localProjectName;
+    scaffoldSkill({
+        ...args,
+        project,
+        targetRoot,
+    });
+    registry.refresh();
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Successfully created ${args.scope} skill "${args.name}"${project ? ` for project "${project}"` : ` in category "${args.category}"`}.`,
+            },
+        ],
+        metadata: {
+            scope: args.scope,
+            project,
+        },
+    };
+}

package/dist/tools/get_doc.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import type { Registry } from '../registry.js';
+export declare const getDocSchema: z.ZodObject<{
+    name: z.ZodString;
+    section: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    section?: string | undefined;
+}, {
+    name: string;
+    section?: string | undefined;
+}>;
+export declare function getDoc(registry: Registry, args: z.infer<typeof getDocSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    metadata: {
+        tokenEstimate: number;
+    };
+}>;

package/dist/tools/get_doc.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { loadDocSection } from '../loader.js';
+export const getDocSchema = z.object({
+    name: z.string(),
+    section: z.string().optional(),
+});
+export async function getDoc(registry, args) {
+    const manifest = registry.getDoc(args.name);
+    if (!manifest) {
+        throw new Error(`Document "${args.name}" not found.`);
+    }
+    const fragment = loadDocSection(manifest.filePath, args.section);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: fragment.content,
+            },
+        ],
+        metadata: {
+            tokenEstimate: fragment.tokenEstimate,
+        },
+    };
+}

package/dist/tools/get_persona.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import type { Registry } from '../registry.js';
+export declare const getPersonaSchema: z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+}, {
+    name: string;
+}>;
+export declare function getPersona(registry: Registry, args: z.infer<typeof getPersonaSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/get_persona.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { readFileSync } from 'fs';
+export const getPersonaSchema = z.object({
+    name: z.string(),
+});
+export async function getPersona(registry, args) {
+    const manifest = registry.getPersona(args.name);
+    if (!manifest) {
+        throw new Error(`Persona "${args.name}" not found.`);
+    }
+    const content = readFileSync(manifest.filePath, 'utf-8');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: content,
+            },
+        ],
+    };
+}

package/dist/tools/get_reference.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import type { Registry } from '../registry.js';
+export declare const getReferenceSchema: z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+}, {
+    name: string;
+}>;
+export declare function getReference(registry: Registry, args: z.infer<typeof getReferenceSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/get_reference.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { readFileSync } from 'fs';
+export const getReferenceSchema = z.object({
+    name: z.string(),
+});
+export async function getReference(registry, args) {
+    const manifest = registry.getReference(args.name);
+    if (!manifest) {
+        throw new Error(`Reference "${args.name}" not found.`);
+    }
+    const content = readFileSync(manifest.filePath, 'utf-8');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: content,
+            },
+        ],
+    };
+}

package/dist/tools/get_skill.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import type { Registry } from '../registry.js';
+export declare const getSkillSchema: z.ZodObject<{
+    name: z.ZodString;
+    section: z.ZodDefault<z.ZodOptional<z.ZodEnum<["description", "overview", "when_to_use", "workflow", "usage", "detailed_instructions", "phases", "checklist", "red_flags", "rationalizations", "full"]>>>;
+    file: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    section: "description" | "overview" | "when_to_use" | "workflow" | "usage" | "detailed_instructions" | "phases" | "checklist" | "red_flags" | "rationalizations" | "full";
+    file?: string | undefined;
+}, {
+    name: string;
+    section?: "description" | "overview" | "when_to_use" | "workflow" | "usage" | "detailed_instructions" | "phases" | "checklist" | "red_flags" | "rationalizations" | "full" | undefined;
+    file?: string | undefined;
+}>;
+export declare function getSkill(registry: Registry, args: z.infer<typeof getSkillSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    metadata: {
+        scope: import("../types.js").SkillScope;
+        tokenEstimate?: undefined;
+    };
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    metadata: {
+        scope: import("../types.js").SkillScope | undefined;
+        tokenEstimate: number;
+    };
+}>;

package/dist/tools/get_skill.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { readFileSync } from 'fs';
+import { dirname, normalize, resolve } from 'path';
+import { loadSkillSection } from '../loader.js';
+export const getSkillSchema = z.object({
+    name: z.string(),
+    section: z.enum([
+        'description',
+        'overview',
+        'when_to_use',
+        'workflow',
+        'usage',
+        'detailed_instructions',
+        'phases',
+        'checklist',
+        'red_flags',
+        'rationalizations',
+        'full',
+    ]).optional().default('workflow'),
+    file: z.string().optional(),
+});
+export async function getSkill(registry, args) {
+    const manifest = registry.getSkill(args.name);
+    if (!manifest) {
+        throw new Error(`Skill "${args.name}" not found.`);
+    }
+    if (args.file) {
+        const skillDir = dirname(manifest.filePath);
+        const targetPath = resolve(skillDir, normalize(args.file));
+        if (!targetPath.startsWith(resolve(skillDir))) {
+            throw new Error('Directory traversal is not allowed.');
+        }
+        let content;
+        try {
+            content = readFileSync(targetPath, 'utf-8');
+        }
+        catch (err) {
+            throw new Error(`Could not read file "${args.file}" in skill "${args.name}": ${err.message}`);
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: content,
+                },
+            ],
+            metadata: {
+                scope: manifest.scope,
+            },
+        };
+    }
+    const fragment = loadSkillSection(manifest.filePath, args.section, manifest.scope);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: fragment.content,
+            },
+        ],
+        metadata: {
+            scope: fragment.scope,
+            tokenEstimate: fragment.tokenEstimate,
+        },
+    };
+}

package/dist/tools/get_template_doc.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import type { Registry } from '../registry.js';
+export declare const getTemplateDocSchema: z.ZodObject<{
+    name: z.ZodString;
+    section: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    section?: string | undefined;
+}, {
+    name: string;
+    section?: string | undefined;
+}>;
+export declare function getTemplateDoc(registry: Registry, args: z.infer<typeof getTemplateDocSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    metadata: {
+        tokenEstimate: number;
+    };
+}>;

package/dist/tools/get_template_doc.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { loadDocSection } from '../loader.js';
+export const getTemplateDocSchema = z.object({
+    name: z.string(),
+    section: z.string().optional(),
+});
+export async function getTemplateDoc(registry, args) {
+    const manifest = registry.getDoc(args.name);
+    if (!manifest) {
+        throw new Error(`Document "${args.name}" not found.`);
+    }
+    const fragment = loadDocSection(manifest.filePath, args.section);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: fragment.content,
+            },
+        ],
+        metadata: {
+            tokenEstimate: fragment.tokenEstimate,
+        },
+    };
+}

package/dist/tools/list_docs.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import type { Registry } from '../registry.js';
+export declare const listDocsSchema: z.ZodObject<{
+    category: z.ZodOptional<z.ZodEnum<["api", "design", "schema", "deployment", "hooks", "strategy", "other"]>>;
+}, "strip", z.ZodTypeAny, {
+    category?: "api" | "design" | "schema" | "deployment" | "hooks" | "strategy" | "other" | undefined;
+}, {
+    category?: "api" | "design" | "schema" | "deployment" | "hooks" | "strategy" | "other" | undefined;
+}>;
+export declare function listDocs(registry: Registry, args: z.infer<typeof listDocsSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/list_docs.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export const listDocsSchema = z.object({
+    category: z.enum(['api', 'design', 'schema', 'deployment', 'hooks', 'strategy', 'other']).optional(),
+});
+export async function listDocs(registry, args) {
+    const docs = registry.listDocs(args.category);
+    const sanitized = docs.map(({ filePath, ...rest }) => rest);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(sanitized, null, 2),
+            },
+        ],
+    };
+}

package/dist/tools/list_skills.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { Registry } from '../registry.js';
+export declare const listSkillsSchema: z.ZodObject<{
+    category: z.ZodOptional<z.ZodString>;
+    scope: z.ZodDefault<z.ZodOptional<z.ZodEnum<["global", "local", "all"]>>>;
+}, "strip", z.ZodTypeAny, {
+    scope: "global" | "local" | "all";
+    category?: string | undefined;
+}, {
+    category?: string | undefined;
+    scope?: "global" | "local" | "all" | undefined;
+}>;
+export declare function listSkills(registry: Registry, args: z.infer<typeof listSkillsSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/list_skills.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export const listSkillsSchema = z.object({
+    category: z.string().optional(),
+    scope: z.enum(['global', 'local', 'all']).optional().default('all'),
+});
+export async function listSkills(registry, args) {
+    const skills = registry.listSkills(args.category, args.scope);
+    const sanitized = skills.map(({ filePath, ...rest }) => rest);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(sanitized, null, 2),
+            },
+        ],
+    };
+}

package/dist/tools/list_template_docs.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import type { Registry } from '../registry.js';
+export declare const listTemplateDocsSchema: z.ZodObject<{
+    category: z.ZodOptional<z.ZodEnum<["api", "design", "schema", "deployment", "hooks", "strategy", "other"]>>;
+}, "strip", z.ZodTypeAny, {
+    category?: "api" | "design" | "schema" | "deployment" | "hooks" | "strategy" | "other" | undefined;
+}, {
+    category?: "api" | "design" | "schema" | "deployment" | "hooks" | "strategy" | "other" | undefined;
+}>;
+export declare function listTemplateDocs(registry: Registry, args: z.infer<typeof listTemplateDocsSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/list_template_docs.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export const listTemplateDocsSchema = z.object({
+    category: z.enum(['api', 'design', 'schema', 'deployment', 'hooks', 'strategy', 'other']).optional(),
+});
+export async function listTemplateDocs(registry, args) {
+    const docs = registry.listDocs(args.category);
+    const sanitized = docs.map(({ filePath, ...rest }) => rest);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(sanitized, null, 2),
+            },
+        ],
+    };
+}