frontmcp 0.0.1 → 0.1.3

package/dist/cli.js

@@ -0,0 +1,595 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * frontmcp - FrontMCP command line interface
+ * Save as bin/frontmcp.ts (compile to JS with shebang preserved) or run with tsx.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const COLORS = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+const c = (color, s) => COLORS[color] + s + COLORS.reset;
+function showHelp() {
+    console.log(`
+${c('bold', 'frontmcp')} — FrontMCP command line interface
+
+${c('bold', 'Usage')}
+  frontmcp <command> [options]
+
+${c('bold', 'Commands')}
+  dev                 Start in development mode (tsx --watch <entry>)
+  build               Compile entry with TypeScript (tsc)
+  init                Create or fix a tsconfig.json suitable for FrontMCP
+  doctor              Check Node/npm versions and tsconfig requirements
+  inspector           Launch MCP Inspector (npx @modelcontextprotocol/inspector)
+  create              Scaffold a new FrontMCP project in the current directory
+  help                Show this help message
+
+${c('bold', 'Options')}
+  -o, --out-dir <dir>  Output directory (default: ./dist)
+  -e, --entry <path>   Manually specify entry file path
+
+${c('bold', 'Examples')}
+  frontmcp dev
+  frontmcp build --out-dir build
+  frontmcp init
+  frontmcp doctor
+  frontmcp inspector
+  npx frontmcp create
+`);
+}
+function parseArgs(argv) {
+    const out = { _: [] };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--out-dir' || a === '-o')
+            out.outDir = argv[++i];
+        else if (a === '--entry' || a === '-e')
+            out.entry = argv[++i];
+        else if (a === '--help' || a === '-h')
+            out.help = true;
+        else
+            out._.push(a);
+    }
+    return out;
+}
+function fileExists(p) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield fs_1.promises.access(p, fs.constants.F_OK);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+function readJSON(jsonPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const buf = yield fs_1.promises.readFile(jsonPath, 'utf8');
+            return JSON.parse(buf);
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}
+function writeJSON(p, obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield fs_1.promises.writeFile(p, JSON.stringify(obj, null, 2) + '\n', 'utf8');
+    });
+}
+function tryCandidates(base) {
+    const exts = ['', '.ts', '.tsx', '.js', '.mjs', '.cjs'];
+    return exts.map((ext) => base + ext);
+}
+function resolveEntry(cwd, explicit) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (explicit) {
+            const full = path.resolve(cwd, explicit);
+            if (yield fileExists(full))
+                return full;
+            throw new Error(`Entry override not found: ${explicit}`);
+        }
+        // 1) package.json main
+        const pkgPath = path.join(cwd, 'package.json');
+        if (yield fileExists(pkgPath)) {
+            const pkg = yield readJSON(pkgPath);
+            if (pkg && typeof pkg.main === 'string' && pkg.main.trim()) {
+                const mainCandidates = tryCandidates(path.resolve(cwd, pkg.main));
+                for (const p of mainCandidates) {
+                    if (yield fileExists(p))
+                        return p;
+                }
+                // If "main" is a directory-like path, try index.* within it
+                const asDir = path.resolve(cwd, pkg.main);
+                const idxCandidates = tryCandidates(path.join(asDir, 'index'));
+                for (const p of idxCandidates) {
+                    if (yield fileExists(p))
+                        return p;
+                }
+            }
+        }
+        // 2) src/main.ts
+        const fallback = path.join(cwd, 'src', 'main.ts');
+        if (yield fileExists(fallback))
+            return fallback;
+        // 3) Not found
+        const msg = [
+            c('red', 'No entry file found.'),
+            '',
+            'I looked for:',
+            `  • ${pkgPath} with a valid "main" field`,
+            `  • ${path.relative(cwd, fallback)}`,
+            '',
+            'Please create an entry file (e.g. src/main.ts) or set "main" in package.json,',
+            'or run with an explicit path:',
+            `  frontmcp dev --entry src/main.ts`,
+        ].join('\n');
+        throw new Error(msg);
+    });
+}
+function runCmd(cmd, args, opts = {}) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(cmd, args, Object.assign({ stdio: 'inherit', shell: true }, opts));
+        child.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`${cmd} exited with code ${code}`))));
+        child.on('error', reject);
+    });
+}
+/* --------------------------------- Actions -------------------------------- */
+function runDev(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cwd = process.cwd();
+        const entry = yield resolveEntry(cwd, opts.entry);
+        console.log(`${c('cyan', '[dev]')} using entry: ${path.relative(cwd, entry)}`);
+        console.log(`${c('gray', 'hint:')} press Ctrl+C to stop`);
+        yield runCmd('npx', ['-y', 'tsx', '--watch', entry]);
+    });
+}
+function ensureDir(p) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield fs_1.promises.mkdir(p, { recursive: true });
+    });
+}
+function isTsLike(p) {
+    return /\.tsx?$/i.test(p);
+}
+function runBuild(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cwd = process.cwd();
+        const entry = yield resolveEntry(cwd, opts.entry);
+        const outDir = path.resolve(cwd, opts.outDir || 'dist');
+        yield ensureDir(outDir);
+        console.log(`${c('cyan', '[build]')} entry: ${path.relative(cwd, entry)}`);
+        console.log(`${c('cyan', '[build]')} outDir: ${path.relative(cwd, outDir)}`);
+        const args = [];
+        args.push('--outDir', outDir);
+        args.push('--skipLibCheck');
+        args.push('--rootDir', path.dirname(entry));
+        if (!isTsLike(entry)) {
+            args.push('--allowJs');
+            console.log(c('yellow', '[build] Entry is not TypeScript; enabling --allowJs'));
+        }
+        const tsconfigPath = path.join(cwd, 'tsconfig.json');
+        if (yield fileExists(tsconfigPath)) {
+            console.log(c('gray', `[build] tsconfig.json detected (project options will be respected where applicable)`));
+        }
+        // Compile the single entry file
+        yield runCmd('npx', ['-y', 'tsc', entry, ...args]);
+        console.log(c('green', '✅ Build completed.'));
+        console.log(c('gray', `Output placed in ${path.relative(cwd, outDir)}`));
+    });
+}
+/* --------------------------- tsconfig management --------------------------- */
+const REQUIRED_DECORATOR_FIELDS = {
+    target: 'es2021',
+    module: 'esnext',
+    emitDecoratorMetadata: true,
+    experimentalDecorators: true,
+};
+const RECOMMENDED_TSCONFIG = {
+    compilerOptions: {
+        target: REQUIRED_DECORATOR_FIELDS.target,
+        module: REQUIRED_DECORATOR_FIELDS.module,
+        emitDecoratorMetadata: REQUIRED_DECORATOR_FIELDS.emitDecoratorMetadata,
+        experimentalDecorators: REQUIRED_DECORATOR_FIELDS.experimentalDecorators,
+        moduleResolution: 'NodeNext',
+        strict: true,
+        esModuleInterop: true,
+        resolveJsonModule: true,
+        skipLibCheck: true,
+        sourceMap: true,
+        outDir: 'dist',
+        rootDir: 'src',
+        types: ['node'],
+    },
+    include: ['src/**/*'],
+};
+function deepMerge(base, patch) {
+    var _a;
+    const out = Object.assign({}, base);
+    for (const [k, v] of Object.entries(patch)) {
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+            out[k] = deepMerge((_a = base[k]) !== null && _a !== void 0 ? _a : {}, v);
+        }
+        else {
+            out[k] = v;
+        }
+    }
+    return out;
+}
+function ensureRequiredTsOptions(obj) {
+    const next = Object.assign({}, obj);
+    next.compilerOptions = Object.assign({}, (next.compilerOptions || {}));
+    // Force the required values
+    next.compilerOptions.target = REQUIRED_DECORATOR_FIELDS.target;
+    next.compilerOptions.module = REQUIRED_DECORATOR_FIELDS.module;
+    next.compilerOptions.emitDecoratorMetadata = REQUIRED_DECORATOR_FIELDS.emitDecoratorMetadata;
+    next.compilerOptions.experimentalDecorators = REQUIRED_DECORATOR_FIELDS.experimentalDecorators;
+    return next;
+}
+function normalizeStr(x) {
+    return typeof x === 'string' ? x.toLowerCase() : undefined;
+}
+function checkRequiredTsOptions(compilerOptions) {
+    const issues = [];
+    const ok = [];
+    const target = normalizeStr(compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.target);
+    const moduleVal = normalizeStr(compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.module);
+    const edm = compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.emitDecoratorMetadata;
+    const ed = compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.experimentalDecorators;
+    if (target === REQUIRED_DECORATOR_FIELDS.target)
+        ok.push(`compilerOptions.target = "${REQUIRED_DECORATOR_FIELDS.target}"`);
+    else
+        issues.push(`compilerOptions.target should be "${REQUIRED_DECORATOR_FIELDS.target}"`);
+    if (moduleVal === REQUIRED_DECORATOR_FIELDS.module)
+        ok.push(`compilerOptions.module = "${REQUIRED_DECORATOR_FIELDS.module}"`);
+    else
+        issues.push(`compilerOptions.module should be "${REQUIRED_DECORATOR_FIELDS.module}"`);
+    if (edm === REQUIRED_DECORATOR_FIELDS.emitDecoratorMetadata)
+        ok.push(`compilerOptions.emitDecoratorMetadata = true`);
+    else
+        issues.push(`compilerOptions.emitDecoratorMetadata should be true`);
+    if (ed === REQUIRED_DECORATOR_FIELDS.experimentalDecorators)
+        ok.push(`compilerOptions.experimentalDecorators = true`);
+    else
+        issues.push(`compilerOptions.experimentalDecorators should be true`);
+    return { ok, issues };
+}
+function runInit() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cwd = process.cwd();
+        const tsconfigPath = path.join(cwd, 'tsconfig.json');
+        const existing = yield readJSON(tsconfigPath);
+        if (!existing) {
+            console.log(c('yellow', 'tsconfig.json not found — creating one.'));
+            yield writeJSON(tsconfigPath, RECOMMENDED_TSCONFIG);
+            console.log(c('green', '✅ Created tsconfig.json with required decorator settings.'));
+            return;
+        }
+        // Merge user config on top of recommended, then force required decorator options
+        let merged = deepMerge(RECOMMENDED_TSCONFIG, existing);
+        merged = ensureRequiredTsOptions(merged);
+        yield writeJSON(tsconfigPath, merged);
+        console.log(c('green', '✅ tsconfig.json verified and updated (required decorator settings enforced).'));
+    });
+}
+function cmpSemver(a, b) {
+    const pa = a.split('.').map((n) => parseInt(n, 10) || 0);
+    const pb = b.split('.').map((n) => parseInt(n, 10) || 0);
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] || 0) > (pb[i] || 0))
+            return 1;
+        if ((pa[i] || 0) < (pb[i] || 0))
+            return -1;
+    }
+    return 0;
+}
+function runDoctor() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const MIN_NODE = '22.0.0';
+        const MIN_NPM = '10.0.0';
+        const cwd = process.cwd();
+        let ok = true;
+        // Node
+        const nodeVer = process.versions.node;
+        if (cmpSemver(nodeVer, MIN_NODE) >= 0) {
+            console.log(`✅ Node ${nodeVer} (min ${MIN_NODE})`);
+        }
+        else {
+            ok = false;
+            console.log(`❌ Node ${nodeVer} — please upgrade to >= ${MIN_NODE}`);
+        }
+        // npm
+        let npmVer = 'unknown';
+        try {
+            npmVer = yield new Promise((resolve, reject) => {
+                var _a;
+                const child = (0, child_process_1.spawn)('npm', ['-v'], { shell: true });
+                let out = '';
+                (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (d) => (out += String(d)));
+                child.on('close', () => resolve(out.trim()));
+                child.on('error', reject);
+            });
+            if (cmpSemver(npmVer, MIN_NPM) >= 0) {
+                console.log(`✅ npm ${npmVer} (min ${MIN_NPM})`);
+            }
+            else {
+                ok = false;
+                console.log(`❌ npm ${npmVer} — please upgrade to >= ${MIN_NPM}`);
+            }
+        }
+        catch (_d) {
+            ok = false;
+            console.log('❌ npm not found in PATH');
+        }
+        // tsconfig.json presence + required fields
+        const tsconfigPath = path.join(cwd, 'tsconfig.json');
+        if (yield fileExists(tsconfigPath)) {
+            console.log(`✅ tsconfig.json found`);
+            const tsconfig = yield readJSON(tsconfigPath);
+            const { ok: oks, issues } = checkRequiredTsOptions(tsconfig === null || tsconfig === void 0 ? void 0 : tsconfig.compilerOptions);
+            for (const line of oks)
+                console.log(c('green', `  ✓ ${line}`));
+            if (issues.length) {
+                ok = false;
+                for (const line of issues)
+                    console.log(c('yellow', `  • ${line}`));
+                console.log(c('cyan', `  -> Run "frontmcp init" to apply the required settings.`));
+            }
+        }
+        else {
+            ok = false;
+            console.log(`❌ tsconfig.json not found — run ${c('cyan', 'frontmcp init')}`);
+        }
+        // Entry check (nice to have)
+        try {
+            const entry = yield resolveEntry(cwd);
+            console.log(`✅ entry detected: ${path.relative(cwd, entry)}`);
+        }
+        catch (e) {
+            const firstLine = (_c = (_b = (_a = e === null || e === void 0 ? void 0 : e.message) === null || _a === void 0 ? void 0 : _a.split('\n')) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : 'entry not found';
+            console.log(`❌ entry not detected — ${firstLine}`);
+        }
+        if (ok) {
+            console.log(c('green', '\nAll checks passed. You are ready to go!'));
+        }
+        else {
+            console.log(c('yellow', '\nSome checks failed. See above for fixes.'));
+        }
+    });
+}
+/* ------------------------------- Inspector -------------------------------- */
+function runInspector() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(`${c('cyan', '[inspector]')} launching MCP Inspector...`);
+        yield runCmd('npx', ['-y', '@modelcontextprotocol/inspector']);
+    });
+}
+/* --------------------------------- Create --------------------------------- */
+function pkgNameFromCwd(cwd) {
+    return path.basename(cwd).replace(/[^a-zA-Z0-9._-]/g, '-').toLowerCase() || 'frontmcp-app';
+}
+function upsertPackageJson(cwd) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        const pkgPath = path.join(cwd, 'package.json');
+        const existing = yield readJSON(pkgPath);
+        const base = {
+            name: pkgNameFromCwd(cwd),
+            version: '0.1.0',
+            private: true,
+            type: 'module',
+            main: 'src/main.ts',
+            scripts: {
+                dev: 'frontmcp dev',
+                build: 'frontmcp build',
+                inspect: 'frontmcp inspector',
+                doctor: 'frontmcp doctor',
+            },
+            engines: {
+                node: '>=22',
+                npm: '>=10',
+            },
+            dependencies: {
+                '@frontmcp/sdk': 'latest',
+                zod: 'latest',
+            },
+            devDependencies: {
+                typescript: 'latest',
+                tsx: 'latest',
+            },
+        };
+        if (!existing) {
+            yield writeJSON(pkgPath, base);
+            console.log(c('green', '✅ Created package.json (with scripts: dev, build, inspect, doctor)'));
+            return;
+        }
+        // Merge, preserving user fields; ensure our requirements exist
+        const merged = Object.assign(Object.assign({}, base), existing);
+        merged.main = existing.main || base.main;
+        merged.type = existing.type || base.type;
+        merged.scripts = Object.assign(Object.assign(Object.assign({}, base.scripts), (existing.scripts || {})), { dev: ((_b = (_a = existing.scripts) === null || _a === void 0 ? void 0 : _a.dev) !== null && _b !== void 0 ? _b : base.scripts.dev), build: ((_d = (_c = existing.scripts) === null || _c === void 0 ? void 0 : _c.build) !== null && _d !== void 0 ? _d : base.scripts.build), inspect: ((_f = (_e = existing.scripts) === null || _e === void 0 ? void 0 : _e.inspect) !== null && _f !== void 0 ? _f : base.scripts.inspect), doctor: ((_h = (_g = existing.scripts) === null || _g === void 0 ? void 0 : _g.doctor) !== null && _h !== void 0 ? _h : base.scripts.doctor) });
+        merged.engines = Object.assign(Object.assign({}, (existing.engines || {})), { node: ((_j = existing.engines) === null || _j === void 0 ? void 0 : _j.node) || base.engines.node, npm: ((_k = existing.engines) === null || _k === void 0 ? void 0 : _k.npm) || base.engines.npm });
+        merged.dependencies = Object.assign(Object.assign({}, existing.dependencies), { '@frontmcp/sdk': ((_l = existing.dependencies) === null || _l === void 0 ? void 0 : _l['@frontmcp/sdk']) || base.dependencies['@frontmcp/sdk'], zod: ((_m = existing.dependencies) === null || _m === void 0 ? void 0 : _m.zod) || base.dependencies.zod });
+        merged.devDependencies = Object.assign(Object.assign({}, existing.devDependencies), { typescript: ((_o = existing.devDependencies) === null || _o === void 0 ? void 0 : _o.typescript) || base.devDependencies.typescript, tsx: ((_p = existing.devDependencies) === null || _p === void 0 ? void 0 : _p.tsx) || base.devDependencies.tsx });
+        yield writeJSON(pkgPath, merged);
+        console.log(c('green', '✅ Updated package.json (ensured scripts, engines, deps)'));
+    });
+}
+function scaffoldFileIfMissing(p, content) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (yield fileExists(p)) {
+            console.log(c('gray', `skip: ${path.relative(process.cwd(), p)} already exists`));
+            return;
+        }
+        yield ensureDir(path.dirname(p));
+        yield fs_1.promises.writeFile(p, content.replace(/^\n/, ''), 'utf8');
+        console.log(c('green', `✓ created ${path.relative(process.cwd(), p)}`));
+    });
+}
+const TEMPLATE_MAIN_TS = `
+import 'reflect-metadata';
+import { FrontMcp } from '@frontmcp/sdk';
+import { CalcApp } from './calc.app';
+
+@FrontMcp({
+  info: { name: 'Demo 🚀', version: '0.1.0' },
+  apps: [CalcApp],
+  auth: {
+    type: 'remote',
+    name: 'my-remote-auth',
+    baseUrl: 'https://idp.example.com',
+  },
+})
+export default class Server {}
+`;
+const TEMPLATE_CALC_APP_TS = `
+import { App } from '@frontmcp/sdk';
+import AddTool from './tools/add.tool';
+
+@App({
+  id: 'calc',
+  name: 'Calculator',
+  tools: [AddTool],
+})
+export class CalcApp {}
+`;
+const TEMPLATE_ADD_TOOL_TS = `
+import { tool } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+const AddTool = tool({
+  name: 'add',
+  description: 'Add two numbers',
+  inputSchema: z.object({ a: z.number(), b: z.number() }),
+  outputSchema: z.object({ result: z.number() }),
+})((input, _ctx) => {
+  return { result: input.a + input.b };
+});
+
+export default AddTool;
+`;
+function runCreate() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cwd = process.cwd();
+        console.log(c('cyan', '[create]'), 'Scaffolding FrontMCP project in', c('bold', cwd));
+        // 1) tsconfig
+        yield runInit();
+        // 2) package.json
+        yield upsertPackageJson(cwd);
+        // 3) files
+        yield scaffoldFileIfMissing(path.join(cwd, 'src', 'main.ts'), TEMPLATE_MAIN_TS);
+        yield scaffoldFileIfMissing(path.join(cwd, 'src', 'calc.app.ts'), TEMPLATE_CALC_APP_TS);
+        yield scaffoldFileIfMissing(path.join(cwd, 'src', 'tools', 'add.tool.ts'), TEMPLATE_ADD_TOOL_TS);
+        // 4) final tips
+        console.log('\nNext steps:');
+        console.log('  1) npm install');
+        console.log('  2) npm run dev   ', c('gray', '# starts tsx watcher via frontmcp dev'));
+        console.log('  3) npm run inspect', c('gray', '# launch MCP Inspector'));
+        console.log('  4) npm run build ', c('gray', '# compile with tsc via frontmcp build'));
+    });
+}
+/* --------------------------------- Main ----------------------------------- */
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const argv = process.argv.slice(2);
+        const parsed = parseArgs(argv);
+        const cmd = parsed._[0];
+        if (parsed.help || !cmd) {
+            showHelp();
+            process.exit(0);
+        }
+        try {
+            switch (cmd) {
+                case 'dev':
+                    yield runDev(parsed);
+                    break;
+                case 'build':
+                    parsed.outDir = parsed.outDir || 'dist';
+                    yield runBuild(parsed);
+                    break;
+                case 'init':
+                    yield runInit();
+                    break;
+                case 'doctor':
+                    yield runDoctor();
+                    break;
+                case 'inspector':
+                    yield runInspector();
+                    break;
+                case 'create':
+                    yield runCreate();
+                    break;
+                case 'help':
+                    showHelp();
+                    break;
+                default:
+                    console.error(c('red', `Unknown command: ${cmd}`));
+                    showHelp();
+                    process.exitCode = 1;
+            }
+        }
+        catch (err) {
+            console.error('\n' + c('red', err instanceof Error ? err.stack || err.message : String(err)));
+            process.exit(1);
+        }
+    });
+}
+main();

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";
+console.log('Happy developing ✨');

package/package.json

@@ -1,9 +1,26 @@
 {
   "name": "frontmcp",
-  "version": "0.0.1",
-  "description": "",
-  "main": "index.js",
+  "version": "0.1.3",
+  "description": "FrontMCP command line interface",
+  "main": "dist/index.js",
+  "bin": {
+    "frontmcp": "dist/cli.js"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "prepare": "npm run build"
+  },
+  "dependencies": {
+    "@frontmcp/sdk": "0.1.3",
+    "@frontmcp/core": "0.1.3",
+    "@frontmcp/plugins": "0.1.3",
+    "@frontmcp/adapters": "0.1.3",
+    "tsx": "^4.20.6",
+    "typescript": "^5.5.3"
+  },
+  "devDependencies": {
+    "@types/node": "20.19.9",
+    "@modelcontextprotocol/inspector": "^0.17.2"
   }
 }

package/src/cli.ts

@@ -0,0 +1,601 @@
+#!/usr/bin/env node
+/**
+ * frontmcp - FrontMCP command line interface
+ * Save as bin/frontmcp.ts (compile to JS with shebang preserved) or run with tsx.
+ */
+
+import * as fs from 'fs';
+import {promises as fsp} from 'fs';
+import * as path from 'path';
+import {spawn} from 'child_process';
+
+/* ----------------------------- Types & Helpers ---------------------------- */
+
+type Command = 'dev' | 'build' | 'init' | 'doctor' | 'inspector' | 'create' | 'help';
+
+interface ParsedArgs {
+  _: string[];
+  outDir?: string;
+  entry?: string;
+  help?: boolean;
+}
+
+const COLORS = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+} as const;
+
+const c = (color: keyof typeof COLORS, s: string) => COLORS[color] + s + COLORS.reset;
+
+function showHelp(): void {
+  console.log(`
+${c('bold', 'frontmcp')} — FrontMCP command line interface
+
+${c('bold', 'Usage')}
+  frontmcp <command> [options]
+
+${c('bold', 'Commands')}
+  dev                 Start in development mode (tsx --watch <entry>)
+  build               Compile entry with TypeScript (tsc)
+  init                Create or fix a tsconfig.json suitable for FrontMCP
+  doctor              Check Node/npm versions and tsconfig requirements
+  inspector           Launch MCP Inspector (npx @modelcontextprotocol/inspector)
+  create              Scaffold a new FrontMCP project in the current directory
+  help                Show this help message
+
+${c('bold', 'Options')}
+  -o, --out-dir <dir>  Output directory (default: ./dist)
+  -e, --entry <path>   Manually specify entry file path
+
+${c('bold', 'Examples')}
+  frontmcp dev
+  frontmcp build --out-dir build
+  frontmcp init
+  frontmcp doctor
+  frontmcp inspector
+  npx frontmcp create
+`);
+}
+
+function parseArgs(argv: string[]): ParsedArgs {
+  const out: ParsedArgs = {_: []};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--out-dir' || a === '-o') out.outDir = argv[++i];
+    else if (a === '--entry' || a === '-e') out.entry = argv[++i];
+    else if (a === '--help' || a === '-h') out.help = true;
+    else out._.push(a);
+  }
+  return out;
+}
+
+async function fileExists(p: string): Promise<boolean> {
+  try {
+    await fsp.access(p, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJSON<T = any>(jsonPath: string): Promise<T | null> {
+  try {
+    const buf = await fsp.readFile(jsonPath, 'utf8');
+    return JSON.parse(buf) as T;
+  } catch {
+    return null;
+  }
+}
+
+async function writeJSON(p: string, obj: any) {
+  await fsp.writeFile(p, JSON.stringify(obj, null, 2) + '\n', 'utf8');
+}
+
+function tryCandidates(base: string): string[] {
+  const exts = ['', '.ts', '.tsx', '.js', '.mjs', '.cjs'];
+  return exts.map((ext) => base + ext);
+}
+
+async function resolveEntry(cwd: string, explicit?: string): Promise<string> {
+  if (explicit) {
+    const full = path.resolve(cwd, explicit);
+    if (await fileExists(full)) return full;
+    throw new Error(`Entry override not found: ${explicit}`);
+  }
+
+  // 1) package.json main
+  const pkgPath = path.join(cwd, 'package.json');
+  if (await fileExists(pkgPath)) {
+    const pkg = await readJSON<any>(pkgPath);
+    if (pkg && typeof pkg.main === 'string' && pkg.main.trim()) {
+      const mainCandidates = tryCandidates(path.resolve(cwd, pkg.main));
+      for (const p of mainCandidates) {
+        if (await fileExists(p)) return p;
+      }
+      // If "main" is a directory-like path, try index.* within it
+      const asDir = path.resolve(cwd, pkg.main);
+      const idxCandidates = tryCandidates(path.join(asDir, 'index'));
+      for (const p of idxCandidates) {
+        if (await fileExists(p)) return p;
+      }
+    }
+  }
+
+  // 2) src/main.ts
+  const fallback = path.join(cwd, 'src', 'main.ts');
+  if (await fileExists(fallback)) return fallback;
+
+  // 3) Not found
+  const msg = [
+    c('red', 'No entry file found.'),
+    '',
+    'I looked for:',
+    `  • ${pkgPath} with a valid "main" field`,
+    `  • ${path.relative(cwd, fallback)}`,
+    '',
+    'Please create an entry file (e.g. src/main.ts) or set "main" in package.json,',
+    'or run with an explicit path:',
+    `  frontmcp dev --entry src/main.ts`,
+  ].join('\n');
+  throw new Error(msg);
+}
+
+function runCmd(cmd: string, args: string[], opts: { cwd?: string } = {}): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {stdio: 'inherit', shell: true, ...opts});
+    child.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`${cmd} exited with code ${code}`))));
+    child.on('error', reject);
+  });
+}
+
+/* --------------------------------- Actions -------------------------------- */
+
+async function runDev(opts: ParsedArgs): Promise<void> {
+  const cwd = process.cwd();
+  const entry = await resolveEntry(cwd, opts.entry);
+  console.log(`${c('cyan', '[dev]')} using entry: ${path.relative(cwd, entry)}`);
+  console.log(`${c('gray', 'hint:')} press Ctrl+C to stop`);
+  await runCmd('npx', ['-y', 'tsx', '--watch', entry]);
+}
+
+async function ensureDir(p: string): Promise<void> {
+  await fsp.mkdir(p, {recursive: true});
+}
+
+function isTsLike(p: string): boolean {
+  return /\.tsx?$/i.test(p);
+}
+
+async function runBuild(opts: ParsedArgs): Promise<void> {
+  const cwd = process.cwd();
+  const entry = await resolveEntry(cwd, opts.entry);
+  const outDir = path.resolve(cwd, opts.outDir || 'dist');
+  await ensureDir(outDir);
+
+  console.log(`${c('cyan', '[build]')} entry: ${path.relative(cwd, entry)}`);
+  console.log(`${c('cyan', '[build]')} outDir: ${path.relative(cwd, outDir)}`);
+
+  const args: string[] = [];
+  args.push('--outDir', outDir);
+  args.push('--skipLibCheck');
+  args.push('--rootDir', path.dirname(entry));
+
+  if (!isTsLike(entry)) {
+    args.push('--allowJs');
+    console.log(c('yellow', '[build] Entry is not TypeScript; enabling --allowJs'));
+  }
+
+  const tsconfigPath = path.join(cwd, 'tsconfig.json');
+  if (await fileExists(tsconfigPath)) {
+    console.log(c('gray', `[build] tsconfig.json detected (project options will be respected where applicable)`));
+  }
+
+  // Compile the single entry file
+  await runCmd('npx', ['-y', 'tsc', entry, ...args]);
+  console.log(c('green', '✅ Build completed.'));
+  console.log(c('gray', `Output placed in ${path.relative(cwd, outDir)}`));
+}
+
+/* --------------------------- tsconfig management --------------------------- */
+
+const REQUIRED_DECORATOR_FIELDS = {
+  target: 'es2021',
+  module: 'esnext',
+  emitDecoratorMetadata: true,
+  experimentalDecorators: true,
+} as const;
+
+const RECOMMENDED_TSCONFIG = {
+  compilerOptions: {
+    target: REQUIRED_DECORATOR_FIELDS.target,
+    module: REQUIRED_DECORATOR_FIELDS.module,
+    emitDecoratorMetadata: REQUIRED_DECORATOR_FIELDS.emitDecoratorMetadata,
+    experimentalDecorators: REQUIRED_DECORATOR_FIELDS.experimentalDecorators,
+
+    moduleResolution: 'NodeNext',
+    strict: true,
+    esModuleInterop: true,
+    resolveJsonModule: true,
+    skipLibCheck: true,
+    sourceMap: true,
+    outDir: 'dist',
+    rootDir: 'src',
+    types: ['node'],
+  },
+  include: ['src/**/*'],
+} as const;
+
+function deepMerge<T extends Record<string, any>, U extends Record<string, any>>(base: T, patch: U): T & U {
+  const out: Record<string, any> = {...base};
+  for (const [k, v] of Object.entries(patch)) {
+    if (v && typeof v === 'object' && !Array.isArray(v)) {
+      out[k] = deepMerge(base[k] ?? {}, v as Record<string, any>);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out as T & U;
+}
+
+function ensureRequiredTsOptions(obj: Record<string, any>): Record<string, any> {
+  const next = {...obj};
+  next.compilerOptions = {...(next.compilerOptions || {})};
+
+  // Force the required values
+  next.compilerOptions.target = REQUIRED_DECORATOR_FIELDS.target;
+  next.compilerOptions.module = REQUIRED_DECORATOR_FIELDS.module;
+  next.compilerOptions.emitDecoratorMetadata = REQUIRED_DECORATOR_FIELDS.emitDecoratorMetadata;
+  next.compilerOptions.experimentalDecorators = REQUIRED_DECORATOR_FIELDS.experimentalDecorators;
+
+  return next;
+}
+
+function normalizeStr(x: unknown): string | undefined {
+  return typeof x === 'string' ? x.toLowerCase() : undefined;
+}
+
+function checkRequiredTsOptions(compilerOptions: Record<string, any> | undefined) {
+  const issues: string[] = [];
+  const ok: string[] = [];
+
+  const target = normalizeStr(compilerOptions?.target);
+  const moduleVal = normalizeStr(compilerOptions?.module);
+  const edm = compilerOptions?.emitDecoratorMetadata;
+  const ed = compilerOptions?.experimentalDecorators;
+
+  if (target === REQUIRED_DECORATOR_FIELDS.target) ok.push(`compilerOptions.target = "${REQUIRED_DECORATOR_FIELDS.target}"`);
+  else issues.push(`compilerOptions.target should be "${REQUIRED_DECORATOR_FIELDS.target}"`);
+
+  if (moduleVal === REQUIRED_DECORATOR_FIELDS.module) ok.push(`compilerOptions.module = "${REQUIRED_DECORATOR_FIELDS.module}"`);
+  else issues.push(`compilerOptions.module should be "${REQUIRED_DECORATOR_FIELDS.module}"`);
+
+  if (edm === REQUIRED_DECORATOR_FIELDS.emitDecoratorMetadata) ok.push(`compilerOptions.emitDecoratorMetadata = true`);
+  else issues.push(`compilerOptions.emitDecoratorMetadata should be true`);
+
+  if (ed === REQUIRED_DECORATOR_FIELDS.experimentalDecorators) ok.push(`compilerOptions.experimentalDecorators = true`);
+  else issues.push(`compilerOptions.experimentalDecorators should be true`);
+
+  return {ok, issues};
+}
+
+async function runInit(): Promise<void> {
+  const cwd = process.cwd();
+  const tsconfigPath = path.join(cwd, 'tsconfig.json');
+  const existing = await readJSON<Record<string, any>>(tsconfigPath);
+
+  if (!existing) {
+    console.log(c('yellow', 'tsconfig.json not found — creating one.'));
+    await writeJSON(tsconfigPath, RECOMMENDED_TSCONFIG);
+    console.log(c('green', '✅ Created tsconfig.json with required decorator settings.'));
+    return;
+  }
+
+  // Merge user config on top of recommended, then force required decorator options
+  let merged = deepMerge(RECOMMENDED_TSCONFIG as any, existing);
+  merged = ensureRequiredTsOptions(merged);
+
+  await writeJSON(tsconfigPath, merged);
+  console.log(c('green', '✅ tsconfig.json verified and updated (required decorator settings enforced).'));
+}
+
+function cmpSemver(a: string, b: string): number {
+  const pa = a.split('.').map((n) => parseInt(n, 10) || 0);
+  const pb = b.split('.').map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+async function runDoctor(): Promise<void> {
+  const MIN_NODE = '22.0.0';
+  const MIN_NPM = '10.0.0';
+  const cwd = process.cwd();
+
+  let ok = true;
+
+  // Node
+  const nodeVer = process.versions.node;
+  if (cmpSemver(nodeVer, MIN_NODE) >= 0) {
+    console.log(`✅ Node ${nodeVer} (min ${MIN_NODE})`);
+  } else {
+    ok = false;
+    console.log(`❌ Node ${nodeVer} — please upgrade to >= ${MIN_NODE}`);
+  }
+
+  // npm
+  let npmVer = 'unknown';
+  try {
+    npmVer = await new Promise<string>((resolve, reject) => {
+      const child = spawn('npm', ['-v'], {shell: true});
+      let out = '';
+      child.stdout?.on('data', (d) => (out += String(d)));
+      child.on('close', () => resolve(out.trim()));
+      child.on('error', reject);
+    });
+    if (cmpSemver(npmVer, MIN_NPM) >= 0) {
+      console.log(`✅ npm ${npmVer} (min ${MIN_NPM})`);
+    } else {
+      ok = false;
+      console.log(`❌ npm ${npmVer} — please upgrade to >= ${MIN_NPM}`);
+    }
+  } catch {
+    ok = false;
+    console.log('❌ npm not found in PATH');
+  }
+
+  // tsconfig.json presence + required fields
+  const tsconfigPath = path.join(cwd, 'tsconfig.json');
+  if (await fileExists(tsconfigPath)) {
+    console.log(`✅ tsconfig.json found`);
+    const tsconfig = await readJSON<Record<string, any>>(tsconfigPath);
+    const {ok: oks, issues} = checkRequiredTsOptions(tsconfig?.compilerOptions);
+
+    for (const line of oks) console.log(c('green', `  ✓ ${line}`));
+    if (issues.length) {
+      ok = false;
+      for (const line of issues) console.log(c('yellow', `  • ${line}`));
+      console.log(c('cyan', `  -> Run "frontmcp init" to apply the required settings.`));
+    }
+  } else {
+    ok = false;
+    console.log(`❌ tsconfig.json not found — run ${c('cyan', 'frontmcp init')}`);
+  }
+
+  // Entry check (nice to have)
+  try {
+    const entry = await resolveEntry(cwd);
+    console.log(`✅ entry detected: ${path.relative(cwd, entry)}`);
+  } catch (e: any) {
+    const firstLine = (e?.message as string | undefined)?.split('\n')?.[0] ?? 'entry not found';
+    console.log(`❌ entry not detected — ${firstLine}`);
+  }
+
+  if (ok) {
+    console.log(c('green', '\nAll checks passed. You are ready to go!'));
+  } else {
+    console.log(c('yellow', '\nSome checks failed. See above for fixes.'));
+  }
+}
+
+/* ------------------------------- Inspector -------------------------------- */
+
+async function runInspector(): Promise<void> {
+  console.log(`${c('cyan', '[inspector]')} launching MCP Inspector...`);
+  await runCmd('npx', ['-y', '@modelcontextprotocol/inspector']);
+}
+
+/* --------------------------------- Create --------------------------------- */
+
+function pkgNameFromCwd(cwd: string) {
+  return path.basename(cwd).replace(/[^a-zA-Z0-9._-]/g, '-').toLowerCase() || 'frontmcp-app';
+}
+
+async function upsertPackageJson(cwd: string) {
+  const pkgPath = path.join(cwd, 'package.json');
+  const existing = await readJSON<Record<string, any>>(pkgPath);
+
+  const base = {
+    name: pkgNameFromCwd(cwd),
+    version: '0.1.0',
+    private: true,
+    type: 'module',
+    main: 'src/main.ts',
+    scripts: {
+      dev: 'frontmcp dev',
+      build: 'frontmcp build',
+      inspect: 'frontmcp inspector',
+      doctor: 'frontmcp doctor',
+    },
+    engines: {
+      node: '>=22',
+      npm: '>=10',
+    },
+    dependencies: {
+      '@frontmcp/sdk': 'latest',
+      zod: 'latest',
+    },
+    devDependencies: {
+      typescript: 'latest',
+      tsx: 'latest',
+    },
+  };
+
+  if (!existing) {
+    await writeJSON(pkgPath, base);
+    console.log(c('green', '✅ Created package.json (with scripts: dev, build, inspect, doctor)'));
+    return;
+  }
+
+  // Merge, preserving user fields; ensure our requirements exist
+  const merged = {...base, ...existing};
+
+  merged.main = existing.main || base.main;
+  merged.type = existing.type || base.type;
+
+  merged.scripts = {
+    ...base.scripts,
+    ...(existing.scripts || {}),
+    dev: (existing.scripts?.dev ?? base.scripts.dev),
+    build: (existing.scripts?.build ?? base.scripts.build),
+    inspect: (existing.scripts?.inspect ?? base.scripts.inspect),
+    doctor: (existing.scripts?.doctor ?? base.scripts.doctor),
+  };
+
+  merged.engines = {
+    ...(existing.engines || {}),
+    node: existing.engines?.node || base.engines.node,
+    npm: existing.engines?.npm || base.engines.npm,
+  };
+
+  merged.dependencies = {
+    ...existing.dependencies,
+    '@frontmcp/sdk': existing.dependencies?.['@frontmcp/sdk'] || base.dependencies['@frontmcp/sdk'],
+    zod: existing.dependencies?.zod || base.dependencies.zod,
+  };
+
+  merged.devDependencies = {
+    ...existing.devDependencies,
+    typescript: existing.devDependencies?.typescript || base.devDependencies.typescript,
+    tsx: existing.devDependencies?.tsx || base.devDependencies.tsx,
+  };
+
+  await writeJSON(pkgPath, merged);
+  console.log(c('green', '✅ Updated package.json (ensured scripts, engines, deps)'));
+}
+
+async function scaffoldFileIfMissing(p: string, content: string) {
+  if (await fileExists(p)) {
+    console.log(c('gray', `skip: ${path.relative(process.cwd(), p)} already exists`));
+    return;
+  }
+  await ensureDir(path.dirname(p));
+  await fsp.writeFile(p, content.replace(/^\n/, ''), 'utf8');
+  console.log(c('green', `✓ created ${path.relative(process.cwd(), p)}`));
+}
+
+const TEMPLATE_MAIN_TS = `
+import 'reflect-metadata';
+import { FrontMcp } from '@frontmcp/sdk';
+import { CalcApp } from './calc.app';
+
+@FrontMcp({
+  info: { name: 'Demo 🚀', version: '0.1.0' },
+  apps: [CalcApp],
+  auth: {
+    type: 'remote',
+    name: 'my-remote-auth',
+    baseUrl: 'https://idp.example.com',
+  },
+})
+export default class Server {}
+`;
+
+const TEMPLATE_CALC_APP_TS = `
+import { App } from '@frontmcp/sdk';
+import AddTool from './tools/add.tool';
+
+@App({
+  id: 'calc',
+  name: 'Calculator',
+  tools: [AddTool],
+})
+export class CalcApp {}
+`;
+
+const TEMPLATE_ADD_TOOL_TS = `
+import { tool } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+const AddTool = tool({
+  name: 'add',
+  description: 'Add two numbers',
+  inputSchema: z.object({ a: z.number(), b: z.number() }),
+  outputSchema: z.object({ result: z.number() }),
+})((input, _ctx) => {
+  return { result: input.a + input.b };
+});
+
+export default AddTool;
+`;
+
+async function runCreate(): Promise<void> {
+  const cwd = process.cwd();
+
+  console.log(c('cyan', '[create]'), 'Scaffolding FrontMCP project in', c('bold', cwd));
+
+  // 1) tsconfig
+  await runInit();
+
+  // 2) package.json
+  await upsertPackageJson(cwd);
+
+  // 3) files
+  await scaffoldFileIfMissing(path.join(cwd, 'src', 'main.ts'), TEMPLATE_MAIN_TS);
+  await scaffoldFileIfMissing(path.join(cwd, 'src', 'calc.app.ts'), TEMPLATE_CALC_APP_TS);
+  await scaffoldFileIfMissing(path.join(cwd, 'src', 'tools', 'add.tool.ts'), TEMPLATE_ADD_TOOL_TS);
+
+  // 4) final tips
+  console.log('\nNext steps:');
+  console.log('  1) npm install');
+  console.log('  2) npm run dev   ', c('gray', '# starts tsx watcher via frontmcp dev'));
+  console.log('  3) npm run inspect', c('gray', '# launch MCP Inspector'));
+  console.log('  4) npm run build ', c('gray', '# compile with tsc via frontmcp build'));
+}
+
+/* --------------------------------- Main ----------------------------------- */
+
+async function main(): Promise<void> {
+  const argv = process.argv.slice(2);
+  const parsed = parseArgs(argv);
+  const cmd = parsed._[0] as Command | undefined;
+
+  if (parsed.help || !cmd) {
+    showHelp();
+    process.exit(0);
+  }
+
+  try {
+    switch (cmd) {
+      case 'dev':
+        await runDev(parsed);
+        break;
+      case 'build':
+        parsed.outDir = parsed.outDir || 'dist';
+        await runBuild(parsed);
+        break;
+      case 'init':
+        await runInit();
+        break;
+      case 'doctor':
+        await runDoctor();
+        break;
+      case 'inspector':
+        await runInspector();
+        break;
+      case 'create':
+        await runCreate();
+        break;
+      case 'help':
+        showHelp();
+        break;
+      default:
+        console.error(c('red', `Unknown command: ${cmd}`));
+        showHelp();
+        process.exitCode = 1;
+    }
+  } catch (err: any) {
+    console.error('\n' + c('red', err instanceof Error ? err.stack || err.message : String(err)));
+    process.exit(1);
+  }
+}
+
+main();

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist"
+  },
+  "include": [
+    "src"
+  ]
+}

package/.idea/copilot.data.migration.agent.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AgentMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/copilot.data.migration.ask.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AskMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/copilot.data.migration.ask2agent.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="Ask2AgentMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/copilot.data.migration.edit.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="EditMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/mcp.iml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/temp" />
-      <excludeFolder url="file://$MODULE_DIR$/tmp" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/mcp.iml" filepath="$PROJECT_DIR$/.idea/mcp.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>