packkit-mcp 0.1.3 → 0.2.1

package/README.md

@@ -25,6 +25,12 @@ Add to your MCP client config (e.g. Claude Desktop's `claude_desktop_config.json
 
 Then ask your agent things like *"scaffold a React component library called ui with Storybook"* or *"preview a Hono service named api"*.
 
+Also listed on the [official MCP registry](https://registry.modelcontextprotocol.io) as `io.github.DanMat/packkit-mcp` and on [Glama](https://glama.ai/mcp/servers/DanMat/create-packkit).
+
+## Releasing
+
+Publishing a new version touches npm, the official MCP registry and Glama — see **[RELEASING.md](RELEASING.md)**.
+
 ## License
 
 [MIT](https://github.com/DanMat/create-packkit/blob/main/LICENSE) © DanMat

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "packkit-mcp",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "mcpName": "io.github.DanMat/packkit-mcp",
   "description": "MCP server for Packkit — let AI agents scaffold modern npm packages, CLIs, services, and apps as a native tool.",
   "type": "module",
@@ -34,6 +34,6 @@
   "homepage": "https://danmat.github.io/create-packkit/",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "create-packkit": "^2.7.0"
+    "create-packkit": "^2.8.0"
   }
 }

package/server.js

@@ -2,10 +2,18 @@
 // Packkit MCP server — exposes Packkit scaffolding as Model Context Protocol
 // tools so agents (Claude Desktop, Cursor, etc.) can generate projects natively.
 
-import { mkdir, writeFile } from 'node:fs/promises';
-import { existsSync, readdirSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { spawnSync } from 'node:child_process';
+import { join, resolve } from 'node:path';
+import {
+  writeProject,
+  existingEntries,
+  gitInit,
+  installDeps,
+  hasCommand,
+  githubLogin,
+  createGithubRepo,
+  writeLockfile,
+  commitAll,
+} from 'create-packkit/scaffold';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
@@ -27,13 +35,18 @@ const TOOLS = [
   {
     name: 'packkit_schema',
     description:
-      'Return every Packkit option, preset, and shortcut alias as JSON. Call this first to learn what can be configured.',
+      'START HERE. Returns every Packkit option, preset, and shortcut alias as JSON. ' +
+      'Call this before scaffolding so you pick a preset that matches what the user actually wants — ' +
+      'presets range from single libraries to CLIs, HTTP services, SPAs, and full-stack monorepos, ' +
+      'and guessing without reading them is the main cause of scaffolding the wrong shape.',
     inputSchema: { type: 'object', properties: {} },
   },
   {
     name: 'packkit_preview',
     description:
-      'Preview the files Packkit would generate for a config, without writing anything. Returns the stack summary and the file tree.',
+      'Show the project structure a config would produce — the full file tree and stack summary — without writing anything. ' +
+      'Use this to check the layout before committing to it, and to show the user what they are about to get. ' +
+      'Cheap and side-effect free, so prefer it over scaffolding to a throwaway directory to see what happens.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -47,7 +60,10 @@ const TOOLS = [
   {
     name: 'packkit_scaffold',
     description:
-      'Generate a project to disk. Writes files under <directory>/<name> (or ./<name>), optionally runs git init and installs dependencies.',
+      'Generate a project to disk. Writes files under <directory>/<name> (or ./<name>), optionally runs git init, ' +
+      'installs dependencies, and creates the GitHub repository. ' +
+      'Call packkit_schema first if you have not already — picking the preset by guess is how projects end up the wrong shape. ' +
+      'If the target directory already has files in it (an existing clone, for instance), pass merge: true rather than failing.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -57,6 +73,9 @@ const TOOLS = [
         directory: { type: 'string', description: 'Parent directory to create the project in (default: current working directory)' },
         install: { type: 'boolean', description: 'Install dependencies (default false)' },
         git: { type: 'boolean', description: 'git init + initial commit (default false)' },
+        merge: { type: 'boolean', description: 'Scaffold into a non-empty directory. Existing files are never overwritten — colliding ones are skipped and reported. Use this when the target is an already-cloned repo.' },
+        github: { type: 'boolean', description: 'Create the repository on GitHub and push to it, using the `gh` CLI. Requires git. Private unless "public" is set.' },
+        public: { type: 'boolean', description: 'When creating the repository, make it public (default: private)' },
       },
       required: ['name'],
     },
@@ -66,19 +85,11 @@ const TOOLS = [
 const text = (t) => ({ content: [{ type: 'text', text: t }] });
 const fail = (t) => ({ content: [{ type: 'text', text: t }], isError: true });
 
-async function writeProject(targetDir, files) {
-  for (const [rel, contents] of Object.entries(files)) {
-    const full = join(targetDir, rel);
-    await mkdir(dirname(full), { recursive: true });
-    await writeFile(full, contents);
-  }
-}
-
 function fileTree(files) {
   return Object.keys(files).sort().map((p) => `  ${p}`).join('\n');
 }
 
-const server = new Server({ name: 'packkit', version: '0.1.3' }, { capabilities: { tools: {} } });
+const server = new Server({ name: 'packkit', version: '0.2.1' }, { capabilities: { tools: {} } });
 
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
 
@@ -99,25 +110,52 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
       if (!config.name) return fail('A "name" is required.');
       const parent = args.directory ? resolve(args.directory) : process.cwd();
       const targetDir = join(parent, config.name);
-      if (existsSync(targetDir) && readdirSync(targetDir).length > 0) {
-        return fail(`Target directory "${targetDir}" is not empty.`);
+      const occupied = existingEntries(targetDir);
+      if (occupied.length && !args.merge) {
+        return fail(
+          `Target directory "${targetDir}" is not empty (${occupied.slice(0, 4).join(', ')}). ` +
+            'Pass merge: true to scaffold around the existing files — they are never overwritten.',
+        );
       }
+
+      // Creating the repo has to be settled before generating: the repository
+      // URL is baked into package.json links and README badges.
+      let slug = null;
+      if (args.github) {
+        if (!args.git) return fail('github: true also needs git: true — there must be a commit to push.');
+        if (!hasCommand('gh')) return fail('github: true needs the GitHub CLI (https://cli.github.com).');
+        const login = githubLogin();
+        if (!login) return fail('github: true needs an authenticated GitHub CLI. Run: gh auth login');
+        slug = `${login}/${config.name}`;
+        config.repo = `https://github.com/${slug}`;
+      }
+
       const { files, summary } = generate(config);
-      await writeProject(targetDir, files);
+      const { written, skipped } = await writeProject(targetDir, files, { merge: !!args.merge });
 
       const steps = [];
+      if (skipped.length) steps.push(`kept ${skipped.length} existing file(s): ${skipped.join(', ')}`);
       if (args.git) {
-        spawnSync('git', ['init', '--quiet'], { cwd: targetDir });
-        spawnSync('git', ['add', '-A'], { cwd: targetDir });
-        spawnSync('git', ['commit', '-m', 'Initial commit from Packkit', '--quiet'], { cwd: targetDir });
+        gitInit(targetDir);
         steps.push('git initialized');
       }
       if (args.install) {
-        const ok = spawnSync(config.packageManager, ['install'], { cwd: targetDir }).status === 0;
-        steps.push(ok ? 'dependencies installed' : 'install failed (run it manually)');
+        steps.push(installDeps(config.packageManager, targetDir) ? 'dependencies installed' : 'install failed (run it manually)');
+      }
+      if (slug) {
+        // Pushing without a lockfile makes the new repo's first CI run fail.
+        if (!args.install) writeLockfile(config.packageManager, targetDir);
+        commitAll(targetDir, 'Add lockfile');
+        const res = createGithubRepo({
+          slug,
+          description: config.description,
+          private: !args.public,
+          cwd: targetDir,
+        });
+        steps.push(res.ok ? `pushed to ${config.repo}` : `repo creation failed: ${res.error}`);
       }
       return text(
-        `Created ${summary.name} at ${targetDir}\n${summary.fileCount} files · ${summary.stack.join(' · ')}` +
+        `Created ${summary.name} at ${targetDir}\n${written.length} files · ${summary.stack.join(' · ')}` +
           (steps.length ? `\n${steps.join('; ')}` : ''),
       );
     }