@lambertkeith/spec-go 0.2.5 → 0.3.0

package/dist/mcp/index.js

@@ -0,0 +1,591 @@
+#!/usr/bin/env node
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/tools.ts
+import { z } from "zod";
+import path5 from "path";
+
+// src/core/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CONFIG_PATH = path.join(os.homedir(), ".spec-go.json");
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const content = fs.readFileSync(CONFIG_PATH, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return {};
+}
+
+// src/core/debug.ts
+var debugEnabled = false;
+function debug(category, message, data) {
+  if (!debugEnabled) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const prefix = `[DEBUG ${timestamp}] [${category}]`;
+  if (data !== void 0) {
+    const dataStr = formatData(data);
+    console.error(`${prefix} ${message}`, dataStr);
+  } else {
+    console.error(`${prefix} ${message}`);
+  }
+}
+function formatData(data) {
+  try {
+    const str = JSON.stringify(data, null, 2);
+    if (str.length > 500) {
+      return str.slice(0, 500) + "...(truncated)";
+    }
+    return str;
+  } catch {
+    return String(data);
+  }
+}
+
+// src/core/utils.ts
+import path2 from "path";
+import { fileURLToPath } from "url";
+import { spawn } from "child_process";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+function getTemplatesDir() {
+  return path2.resolve(__dirname, "..", "..", "templates");
+}
+function isValidPackageName(name) {
+  return /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(name);
+}
+function toValidPackageName(name) {
+  return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/^[._]/, "").replace(/[^a-z0-9-~]+/g, "-");
+}
+function execAsync(command, args, options = {}) {
+  debug("exec", `\u6267\u884C\u547D\u4EE4: ${command} ${args.join(" ")}`, { cwd: options.cwd });
+  return new Promise((resolve) => {
+    const proc = spawn(command, args, {
+      cwd: options.cwd,
+      stdio: options.stdio === "inherit" ? "inherit" : "pipe",
+      shell: true
+    });
+    let stdout = "";
+    let stderr = "";
+    if (proc.stdout) {
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+    }
+    if (proc.stderr) {
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+    }
+    proc.on("close", (code) => {
+      debug("exec", `\u547D\u4EE4\u5B8C\u6210\uFF0C\u9000\u51FA\u7801: ${code ?? 1}`);
+      resolve({ code: code ?? 1, stdout, stderr });
+    });
+    proc.on("error", (err) => {
+      debug("exec", `\u547D\u4EE4\u9519\u8BEF: ${err.message}`);
+      resolve({ code: 1, stdout, stderr });
+    });
+  });
+}
+
+// src/core/scaffold.ts
+import path3 from "path";
+import fs2 from "fs-extra";
+async function scaffoldProject(options) {
+  const templatesDir = getTemplatesDir();
+  const registryPath = path3.join(templatesDir, "template.config.json");
+  const registry = await fs2.readJson(registryPath);
+  debug("scaffold", `\u5F00\u59CB\u811A\u624B\u67B6\u9879\u76EE: ${options.projectName}`);
+  debug("scaffold", `\u6A21\u677F: ${options.template}`);
+  debug("scaffold", `\u76EE\u6807\u76EE\u5F55: ${options.targetDir}`);
+  const templateEntry = registry.templates.find((t) => t.name === options.template);
+  if (!templateEntry) {
+    throw new Error(`\u672A\u627E\u5230\u6A21\u677F: ${options.template}`);
+  }
+  const templateDir = path3.join(templatesDir, templateEntry.dir);
+  const templateConfigPath = path3.join(templateDir, "_template.json");
+  debug("scaffold", `\u6A21\u677F\u76EE\u5F55: ${templateDir}`);
+  let templateConfig = null;
+  if (await fs2.pathExists(templateConfigPath)) {
+    templateConfig = await fs2.readJson(templateConfigPath);
+    debug("scaffold", "\u6A21\u677F\u914D\u7F6E", templateConfig);
+  }
+  await fs2.ensureDir(options.targetDir);
+  const files = await fs2.readdir(templateDir);
+  debug("scaffold", `\u6A21\u677F\u6587\u4EF6\u6570\u91CF: ${files.length}`);
+  for (const file of files) {
+    if (file === "_template.json") {
+      continue;
+    }
+    const srcPath = path3.join(templateDir, file);
+    let destFileName = file;
+    if (templateConfig?.fileRenames?.[file]) {
+      destFileName = templateConfig.fileRenames[file];
+      if (destFileName === "{{projectName}}") {
+        destFileName = options.projectName;
+      }
+    }
+    const destPath = path3.join(options.targetDir, destFileName);
+    const stat = await fs2.stat(srcPath);
+    debug("scaffold", `\u590D\u5236: ${file} -> ${destFileName}`);
+    if (stat.isDirectory()) {
+      await copyDirectory(srcPath, destPath, options.projectName, templateConfig);
+    } else {
+      await copyFile(srcPath, destPath, options.projectName, templateConfig);
+    }
+  }
+  debug("scaffold", "\u811A\u624B\u67B6\u5B8C\u6210");
+  return templateConfig;
+}
+async function copyDirectory(srcDir, destDir, projectName, config) {
+  await fs2.ensureDir(destDir);
+  const files = await fs2.readdir(srcDir);
+  for (const file of files) {
+    const srcPath = path3.join(srcDir, file);
+    let destFileName = file;
+    if (config?.fileRenames?.[file]) {
+      destFileName = config.fileRenames[file];
+      if (destFileName === "{{projectName}}") {
+        destFileName = projectName;
+      }
+    }
+    const destPath = path3.join(destDir, destFileName);
+    const stat = await fs2.stat(srcPath);
+    if (stat.isDirectory()) {
+      await copyDirectory(srcPath, destPath, projectName, config);
+    } else {
+      await copyFile(srcPath, destPath, projectName, config);
+    }
+  }
+}
+async function copyFile(srcPath, destPath, projectName, config) {
+  const binaryExtensions = [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".ico",
+    ".webp",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".zip",
+    ".tar",
+    ".gz"
+  ];
+  const ext = path3.extname(srcPath).toLowerCase();
+  if (binaryExtensions.includes(ext)) {
+    await fs2.copy(srcPath, destPath);
+    return;
+  }
+  let content = await fs2.readFile(srcPath, "utf-8");
+  content = content.replace(/\{\{projectName\}\}/g, projectName);
+  if (config?.variables) {
+    for (const [key, value] of Object.entries(config.variables)) {
+      const placeholder = `{{${key}}}`;
+      const replacement = value === "{{projectName}}" ? projectName : value;
+      content = content.replace(new RegExp(placeholder.replace(/[{}]/g, "\\$&"), "g"), replacement);
+    }
+  }
+  await fs2.writeFile(destPath, content, "utf-8");
+}
+async function listTemplates() {
+  const templatesDir = getTemplatesDir();
+  const registryPath = path3.join(templatesDir, "template.config.json");
+  return fs2.readJson(registryPath);
+}
+
+// src/core/github-api.ts
+var GITHUB_API_BASE = "https://api.github.com";
+async function githubFetch(endpoint, token, options = {}) {
+  const url = `${GITHUB_API_BASE}${endpoint}`;
+  debug("github-api", `\u8BF7\u6C42: ${options.method || "GET"} ${endpoint}`);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Accept": "application/vnd.github+json",
+        "Authorization": `Bearer ${token}`,
+        "X-GitHub-Api-Version": "2022-11-28",
+        "User-Agent": "spec-go",
+        ...options.headers
+      }
+    });
+    debug("github-api", `\u54CD\u5E94\u72B6\u6001: ${response.status}`);
+    if (response.status === 403) {
+      const rateLimitRemaining = response.headers.get("x-ratelimit-remaining");
+      const rateLimitReset = response.headers.get("x-ratelimit-reset");
+      debug("github-api", `Rate Limit \u4FE1\u606F`, { rateLimitRemaining, rateLimitReset });
+      if (rateLimitRemaining === "0" && rateLimitReset) {
+        const resetDate = new Date(parseInt(rateLimitReset) * 1e3);
+        return {
+          success: false,
+          error: "API \u8BF7\u6C42\u6B21\u6570\u5DF2\u8FBE\u4E0A\u9650",
+          statusCode: 403,
+          rateLimitReset: resetDate
+        };
+      }
+    }
+    if (response.status === 401) {
+      debug("github-api", "Token \u9A8C\u8BC1\u5931\u8D25");
+      return {
+        success: false,
+        error: "Token \u65E0\u6548\u6216\u5DF2\u8FC7\u671F",
+        statusCode: 401
+      };
+    }
+    if (!response.ok) {
+      const errorData = await response.json();
+      debug("github-api", "\u8BF7\u6C42\u5931\u8D25", errorData);
+      return {
+        success: false,
+        error: errorData.message || `\u8BF7\u6C42\u5931\u8D25: ${response.status}`,
+        statusCode: response.status
+      };
+    }
+    const data = await response.json();
+    debug("github-api", "\u8BF7\u6C42\u6210\u529F");
+    return { success: true, data };
+  } catch (err) {
+    debug("github-api", "\u7F51\u7EDC\u8BF7\u6C42\u5F02\u5E38", { error: err instanceof Error ? err.message : String(err) });
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : "\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25"
+    };
+  }
+}
+async function validateToken(token) {
+  return githubFetch("/user", token);
+}
+async function createRepository(token, options) {
+  const endpoint = options.org ? `/orgs/${options.org}/repos` : "/user/repos";
+  const body = {
+    name: options.name,
+    description: options.description || `Created with spec-go`,
+    private: options.isPrivate,
+    auto_init: false
+  };
+  return githubFetch(endpoint, token, {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+}
+
+// src/core/git.ts
+async function initGit(targetDir) {
+  debug("git", `\u521D\u59CB\u5316 Git \u4ED3\u5E93: ${targetDir}`);
+  await execAsync("git", ["init"], { cwd: targetDir });
+  await execAsync("git", ["add", "-A"], { cwd: targetDir });
+  await execAsync("git", ["commit", "-m", "Initial commit"], { cwd: targetDir });
+  debug("git", "Git \u521D\u59CB\u5316\u5B8C\u6210");
+}
+async function createGithubRepoOnly(repoName, isPublic, organization) {
+  const config = loadConfig();
+  if (!config.github?.token) {
+    return {
+      success: false,
+      error: "\u672A\u914D\u7F6E GitHub Token\uFF0C\u8BF7\u8FD0\u884C spec-go config --setup-github \u914D\u7F6E"
+    };
+  }
+  const token = config.github.token;
+  const defaultOrg = organization || config.github.defaultOrg;
+  const validateResult = await validateToken(token);
+  if (!validateResult.success) {
+    return {
+      success: false,
+      error: `GitHub Token \u65E0\u6548: ${validateResult.error}`
+    };
+  }
+  const createResult = await createRepository(token, {
+    name: repoName,
+    isPrivate: !isPublic,
+    org: defaultOrg
+  });
+  if (!createResult.success) {
+    if (createResult.statusCode === 422) {
+      return { success: false, error: `\u4ED3\u5E93 "${repoName}" \u5DF2\u5B58\u5728` };
+    }
+    return { success: false, error: createResult.error };
+  }
+  return {
+    success: true,
+    repoUrl: createResult.data.html_url
+  };
+}
+
+// src/core/post-init.ts
+import path4 from "path";
+
+// src/mcp/tools.ts
+var createProjectSchema = z.object({
+  projectName: z.string().describe("\u9879\u76EE\u540D\u79F0"),
+  template: z.string().describe("\u6A21\u677F\u540D\u79F0\uFF0C\u5982 node-ts, react-ts, vue-ts \u7B49"),
+  targetDir: z.string().optional().describe("\u76EE\u6807\u76EE\u5F55\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u76EE\u5F55\u4E0B\u7684\u9879\u76EE\u540D\u79F0"),
+  skipGit: z.boolean().optional().default(false).describe("\u662F\u5426\u8DF3\u8FC7 Git \u521D\u59CB\u5316"),
+  skipInstall: z.boolean().optional().default(false).describe("\u662F\u5426\u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5")
+});
+var validateProjectNameSchema = z.object({
+  name: z.string().describe("\u8981\u9A8C\u8BC1\u7684\u9879\u76EE\u540D\u79F0")
+});
+var initGitRepoSchema = z.object({
+  targetDir: z.string().describe("\u76EE\u6807\u76EE\u5F55\u7684\u7EDD\u5BF9\u8DEF\u5F84")
+});
+var createGithubRepoSchema = z.object({
+  repoName: z.string().describe("\u4ED3\u5E93\u540D\u79F0"),
+  targetDir: z.string().describe("\u672C\u5730\u9879\u76EE\u76EE\u5F55\u7684\u7EDD\u5BF9\u8DEF\u5F84"),
+  isPublic: z.boolean().optional().default(false).describe("\u662F\u5426\u521B\u5EFA\u516C\u5F00\u4ED3\u5E93"),
+  organization: z.string().optional().describe("GitHub \u7EC4\u7EC7\u540D\u79F0\uFF0C\u4E0D\u586B\u5219\u521B\u5EFA\u5728\u4E2A\u4EBA\u8D26\u6237\u4E0B")
+});
+async function createProject(params) {
+  const { projectName, template, targetDir, skipGit, skipInstall } = params;
+  const validName = toValidPackageName(projectName);
+  if (!isValidPackageName(validName)) {
+    return {
+      success: false,
+      error: `\u65E0\u6548\u7684\u9879\u76EE\u540D\u79F0: ${projectName}`
+    };
+  }
+  const registry = await listTemplates();
+  const templateEntry = registry.templates.find((t) => t.name === template);
+  if (!templateEntry) {
+    const availableTemplates = registry.templates.map((t) => t.name).join(", ");
+    return {
+      success: false,
+      error: `\u672A\u627E\u5230\u6A21\u677F "${template}"\uFF0C\u53EF\u7528\u6A21\u677F: ${availableTemplates}`
+    };
+  }
+  const resolvedTargetDir = targetDir ? path5.resolve(targetDir) : path5.resolve(process.cwd(), validName);
+  const options = {
+    projectName: validName,
+    template,
+    targetDir: resolvedTargetDir,
+    initGit: !skipGit,
+    createGithub: false,
+    isPublic: false,
+    noInstall: skipInstall
+  };
+  try {
+    const templateConfig = await scaffoldProject(options);
+    if (!skipInstall && templateConfig?.postInit) {
+      for (const cmd of templateConfig.postInit) {
+        const [command, ...args] = cmd.command.split(" ");
+        await execAsync(command, args, { cwd: resolvedTargetDir, stdio: "pipe" });
+      }
+    }
+    if (!skipGit) {
+      await initGit(resolvedTargetDir);
+    }
+    return {
+      success: true,
+      projectPath: resolvedTargetDir,
+      template
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function getTemplateList() {
+  const registry = await listTemplates();
+  return {
+    templates: registry.templates.map((t) => ({
+      name: t.name,
+      displayName: t.displayName,
+      description: t.description,
+      category: t.category || "single"
+    }))
+  };
+}
+function validateProjectName(params) {
+  const { name } = params;
+  if (!name || !name.trim()) {
+    return {
+      valid: false,
+      error: "\u9879\u76EE\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A"
+    };
+  }
+  const normalizedName = toValidPackageName(name);
+  if (!isValidPackageName(normalizedName)) {
+    return {
+      valid: false,
+      error: `\u65E0\u6548\u7684\u9879\u76EE\u540D\u79F0: ${name}`
+    };
+  }
+  return {
+    valid: true,
+    normalizedName
+  };
+}
+async function initGitRepo(params) {
+  const { targetDir } = params;
+  try {
+    await initGit(targetDir);
+    return { success: true };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function createGithubRepository(params) {
+  const { repoName, targetDir, isPublic, organization } = params;
+  const result = await createGithubRepoOnly(repoName, isPublic, organization);
+  if (!result.success) {
+    return result;
+  }
+  try {
+    const remoteResult = await execAsync(
+      "git",
+      ["remote", "add", "origin", `https://github.com/${organization || "USER"}/${repoName}.git`],
+      { cwd: targetDir }
+    );
+    if (remoteResult.code !== 0) {
+      await execAsync(
+        "git",
+        ["remote", "set-url", "origin", `https://github.com/${organization || "USER"}/${repoName}.git`],
+        { cwd: targetDir }
+      );
+    }
+    const pushResult = await execAsync(
+      "git",
+      ["push", "-u", "origin", "main"],
+      { cwd: targetDir }
+    );
+    if (pushResult.code !== 0) {
+      const pushMaster = await execAsync(
+        "git",
+        ["push", "-u", "origin", "master"],
+        { cwd: targetDir }
+      );
+      if (pushMaster.code !== 0) {
+        return {
+          success: true,
+          repoUrl: result.repoUrl,
+          error: `\u4ED3\u5E93\u5DF2\u521B\u5EFA\u4F46\u63A8\u9001\u5931\u8D25: ${pushResult.stderr || pushMaster.stderr}`
+        };
+      }
+    }
+    return {
+      success: true,
+      repoUrl: result.repoUrl
+    };
+  } catch (err) {
+    return {
+      success: true,
+      repoUrl: result.repoUrl,
+      error: `\u4ED3\u5E93\u5DF2\u521B\u5EFA\u4F46\u63A8\u9001\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+
+// src/mcp/server.ts
+function createMcpServer() {
+  const server = new McpServer({
+    name: "spec-go",
+    version: "0.2.5"
+  });
+  server.tool(
+    "create_project",
+    "\u4F7F\u7528\u6A21\u677F\u521B\u5EFA\u65B0\u9879\u76EE\u3002\u652F\u6301\u591A\u79CD\u6A21\u677F\u5982 node-ts, react-ts, vue-ts \u7B49\u3002",
+    createProjectSchema.shape,
+    async (params) => {
+      const result = await createProject(params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list_templates",
+    "\u5217\u51FA\u6240\u6709\u53EF\u7528\u7684\u9879\u76EE\u6A21\u677F\uFF0C\u5305\u62EC\u5355\u4F53\u9879\u76EE\u548C\u524D\u540E\u7AEF\u5206\u79BB\u9879\u76EE\u3002",
+    {},
+    async () => {
+      const result = await getTemplateList();
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "validate_project_name",
+    "\u9A8C\u8BC1\u9879\u76EE\u540D\u79F0\u662F\u5426\u6709\u6548\uFF0C\u5E76\u8FD4\u56DE\u89C4\u8303\u5316\u540E\u7684\u540D\u79F0\u3002",
+    validateProjectNameSchema.shape,
+    async (params) => {
+      const result = validateProjectName(params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "init_git_repo",
+    "\u5728\u6307\u5B9A\u76EE\u5F55\u521D\u59CB\u5316 Git \u4ED3\u5E93\uFF0C\u6267\u884C git init\u3001git add \u548C\u521D\u59CB\u63D0\u4EA4\u3002",
+    initGitRepoSchema.shape,
+    async (params) => {
+      const result = await initGitRepo(params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "create_github_repo",
+    "\u521B\u5EFA GitHub \u4ED3\u5E93\u5E76\u5C06\u672C\u5730\u4EE3\u7801\u63A8\u9001\u5230\u8FDC\u7A0B\u3002\u9700\u8981\u5148\u914D\u7F6E GitHub Token\u3002",
+    createGithubRepoSchema.shape,
+    async (params) => {
+      const result = await createGithubRepository(params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  return server;
+}
+async function startServer() {
+  const server = createMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/mcp/index.ts
+startServer().catch((err) => {
+  console.error("MCP Server \u542F\u52A8\u5931\u8D25:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map