@hunyed15/codecgc 0.1.0 → 0.1.2

package/INSTALLATION.md

@@ -34,16 +34,39 @@ npm --version     # 应显示 9.x.x 或更高
 
 ## 安装 CodeCGC
 
-### 方式 1：从源码全局安装（推荐）
+### 方式 1：从 npm 全局安装（推荐）
 
 ```bash
-# 1. 解压 release 包到本地目录
-cd /path/to/codecgc/release
+# 使用 npm 官方源安装
+npm install -g @hunyed15/codecgc --registry=https://registry.npmjs.org/
+```
+
+安装完成后，CodeCGC 会尝试自动执行一次用户级 Claude 集成，相当于：
+
+```bash
+cgc-install --mode user
+```
+
+这会写入：
+
+- `~/.claude/mcp.json`
+- `~/.claude/hooks/route-edit.ps1`
+- `~/.claude/commands/cgc.md`
+- `~/.claude/commands/cgc-install.md`
+- `~/.claude/commands/cgc-status.md`
+- `~/.claude/commands/cgc-doctor.md`
 
-# 2. 全局安装
-npm install -g .
+写入完成后，可以在 Claude 中直接输入：
+
+```text
+/cgc
+/cgc-install
+/cgc-status
+/cgc-doctor
 ```
 
+如果安装阶段因为 Python 未就绪而跳过了这一步，可以在装好 Python 后手动补执行该命令。
+
 安装后，以下命令将全局可用：
 - `cgc`
 - `cgc-install`

package/README.md

@@ -1,4 +1,4 @@
-# CodeCGC Release v0.1.0
+# CodeCGC Release v0.1.2
 
 ## 📦 发布内容
 
@@ -6,7 +6,7 @@
 
 ## 📋 版本信息
 
-- **版本号**: 0.1.0
+- **版本号**: 0.1.2
 - **发布日期**: 2026-05-04
 - **Python 要求**: >= 3.10
 - **Node.js 要求**: >= 20.0.0
@@ -36,20 +36,31 @@
 ### 1. 安装
 
 ```bash
-# 进入 release 目录
-cd /path/to/codecgc/release
-
-# 安装 CodeCGC
-npm install -g .
+# 从 npm 安装 CodeCGC
+npm install -g @hunyed15/codecgc --registry=https://registry.npmjs.org/
 
 # 安装 Python 依赖
 pip install pyyaml
 
-# 安装 MCP 服务器
-cd codexmcp && pip install -e . && cd ..
-cd geminimcp && pip install -e . && cd ..
+# 如自动集成未生效，可手动补执行
+cgc-install --mode user
 ```
 
+全局安装完成后，CodeCGC 会尝试自动写入 Claude 用户级集成到 `~/.claude`，包括：
+
+- `~/.claude/mcp.json`
+- `~/.claude/hooks/route-edit.ps1`
+- `~/.claude/commands/cgc*.md` 自定义 slash commands
+
+安装完成后，可以在 Claude 中直接使用：
+
+- `/cgc`
+- `/cgc-install`
+- `/cgc-status`
+- `/cgc-doctor`
+
+如果安装时 Python 尚未就绪，自动集成会跳过，此时可在安装 Python 后手动执行 `cgc-install --mode user`。
+
 ### 2. 初始化项目
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hunyed15/codecgc",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Claude-hosted multi-model workflow product shell for CodeCGC.",
   "license": "MIT",
   "type": "commonjs",
@@ -23,6 +23,7 @@
     "cgc-route": "bin/cgc-route.js"
   },
   "scripts": {
+    "postinstall": "node scripts/postinstall_codecgc.js",
     "cgc:help": "node bin/cgc.js --help",
     "cgc:status": "node bin/cgc-status.js --format summary",
     "cgc:doctor": "node bin/cgc-doctor.js --format summary",
@@ -39,6 +40,7 @@
   "files": [
     "bin/",
     "scripts/*.py",
+    "scripts/postinstall_codecgc.js",
     "scripts/README-codecgc-cli.md",
     ".claude/hooks/route-edit.ps1",
     "codecgc/cgc/",

package/scripts/install_codecgc.py

@@ -64,6 +64,7 @@ def get_user_claude_paths(override_root: str = "") -> dict[str, Path]:
         "mcp": root / "mcp.json",
         "hooks_dir": root / "hooks",
         "hook_script": root / "hooks" / "route-edit.ps1",
+        "commands_dir": root / "commands",
     }
 
 
@@ -78,6 +79,7 @@ def get_workspace_paths(override_workspace: str = "") -> dict[str, Path]:
         "settings": claude_dir / "settings.json",
         "mcp": root / ".mcp.json",
         "hook_script": hooks_dir / "route-edit.ps1",
+        "commands_dir": claude_dir / "commands",
         "routing_file": root / "model-routing.yaml",
     }
 
@@ -110,6 +112,79 @@ def build_hook_payload(command_text: str) -> dict[str, Any]:
     }
 
 
+def _normalize_command_path_for_markdown(path: Path) -> str:
+    return str(path).replace("\\", "\\\\")
+
+
+def build_custom_command_templates(bin_dir: Path) -> dict[str, str]:
+    cgc_js = _normalize_command_path_for_markdown(bin_dir / "cgc.js")
+    install_js = _normalize_command_path_for_markdown(bin_dir / "cgc-install.js")
+    status_js = _normalize_command_path_for_markdown(bin_dir / "cgc-status.js")
+    doctor_js = _normalize_command_path_for_markdown(bin_dir / "cgc-doctor.js")
+
+    return {
+        "cgc.md": f"""---
+description: Run CodeCGC in the current project
+argument-hint: "[request or flags]"
+---
+Use the Bash tool to run CodeCGC in the current project directory.
+
+- If the user supplied arguments, run:
+  `node "{cgc_js}" $ARGUMENTS`
+- If the user did not supply arguments, run:
+  `node "{cgc_js}" --help`
+- Show the command you ran and summarize the result briefly.
+""",
+        "cgc-install.md": f"""---
+description: Install or sync CodeCGC integration for the current project or user Claude profile
+argument-hint: "[flags]"
+---
+Use the Bash tool to run the CodeCGC install command.
+
+- If the user supplied arguments, run:
+  `node "{install_js}" $ARGUMENTS`
+- If the user did not supply arguments, run:
+  `node "{install_js}"`
+- Show the command you ran and summarize the result briefly.
+""",
+        "cgc-status.md": f"""---
+description: Check CodeCGC integration status
+argument-hint: "[flags]"
+---
+Use the Bash tool to run the CodeCGC status command.
+
+- If the user supplied arguments, run:
+  `node "{status_js}" $ARGUMENTS`
+- If the user did not supply arguments, run:
+  `node "{status_js}"`
+- Show the command you ran and summarize the result briefly.
+""",
+        "cgc-doctor.md": f"""---
+description: Run CodeCGC doctor checks
+argument-hint: "[flags]"
+---
+Use the Bash tool to run the CodeCGC doctor command.
+
+- If the user supplied arguments, run:
+  `node "{doctor_js}" $ARGUMENTS`
+- If the user did not supply arguments, run:
+  `node "{doctor_js}"`
+- Show the command you ran and summarize the result briefly.
+""",
+    }
+
+
+def write_custom_command_files(target_dir: Path, bin_dir: Path) -> list[str]:
+    target_dir.mkdir(parents=True, exist_ok=True)
+    templates = build_custom_command_templates(bin_dir)
+    written: list[str] = []
+    for filename, content in templates.items():
+        path = target_dir / filename
+        path.write_text(content, encoding="utf-8")
+        written.append(str(path))
+    return written
+
+
 def merge_hook_settings(current: dict[str, Any], command_text: str) -> tuple[dict[str, Any], bool]:
     hooks = current.get("hooks")
     expected_hooks = build_hook_payload(command_text)
@@ -240,6 +315,7 @@ def install_local_runtime(override_workspace: str = "") -> dict[str, Any]:
 
     if PROJECT_HOOK_PATH.resolve() != workspace_paths["hook_script"].resolve():
         shutil.copyfile(PROJECT_HOOK_PATH, workspace_paths["hook_script"])
+    written_commands = write_custom_command_files(workspace_paths["commands_dir"], WORKSPACE / "bin")
 
     summary = build_mode_summary_payload(
         scope="项目级 Claude 与 MCP 集成面",
@@ -255,10 +331,13 @@ def install_local_runtime(override_workspace: str = "") -> dict[str, Any]:
         "routing_file": str(routing_path),
         "claude_settings": str(workspace_paths["settings"]),
         "hook_script": str(workspace_paths["hook_script"]),
+        "commands_dir": str(workspace_paths["commands_dir"]),
+        "command_files": written_commands,
         "notes": [
             "Repository-local MCP config was synced from the executor registry.",
             "Project-local model-routing.yaml was synchronized and preserves custom path blocks.",
             "Claude pre-edit guardrail hook was synchronized into the target workspace.",
+            "Project-local Claude slash commands were synchronized into .claude/commands.",
             "This mode prepares project-level integration surfaces for the selected workspace.",
         ],
         "summary": summary,
@@ -290,11 +369,13 @@ def preview_user_install(override_root: str = "") -> dict[str, Any]:
             "settings_json": str(user_paths["settings"]),
             "mcp_json": str(user_paths["mcp"]),
             "hook_script": str(user_paths["hook_script"]),
+            "commands_dir": str(user_paths["commands_dir"]),
         },
         "would_write": {
             "settings_changed": settings_changed or not user_paths["settings"].exists(),
             "mcp_changed": True,
             "hook_changed": True,
+            "commands_changed": True,
         },
         "preview": {
             "settings": sanitize_for_preview(merged_settings),
@@ -313,12 +394,14 @@ def install_user_runtime(override_root: str = "") -> dict[str, Any]:
     user_paths = get_user_claude_paths(override_root)
     user_paths["root"].mkdir(parents=True, exist_ok=True)
     user_paths["hooks_dir"].mkdir(parents=True, exist_ok=True)
+    user_paths["commands_dir"].mkdir(parents=True, exist_ok=True)
 
     settings = load_json_file(user_paths["settings"])
     merged_settings, settings_changed = merge_hook_settings(settings, build_user_hook_command(user_paths))
     write_json_file(user_paths["settings"], merged_settings)
     write_json_file(user_paths["mcp"], build_mcp_config())
     shutil.copyfile(PROJECT_HOOK_PATH, user_paths["hook_script"])
+    written_commands = write_custom_command_files(user_paths["commands_dir"], WORKSPACE / "bin")
     summary = build_mode_summary_payload(
         scope="用户级 Claude 集成面",
         human_summary="用户级 Claude 集成文件已写入。",
@@ -334,15 +417,19 @@ def install_user_runtime(override_root: str = "") -> dict[str, Any]:
             "settings_json": str(user_paths["settings"]),
             "mcp_json": str(user_paths["mcp"]),
             "hook_script": str(user_paths["hook_script"]),
+            "commands_dir": str(user_paths["commands_dir"]),
         },
         "changes": {
             "settings_changed": settings_changed or not user_paths["settings"].exists(),
             "mcp_changed": True,
             "hook_changed": True,
+            "commands_changed": True,
         },
+        "command_files": written_commands,
         "notes": [
             "User-level Claude integration files were written to the selected root.",
             "The user-level hook script was copied from the project hook source.",
+            "User-level Claude slash commands were written to ~/.claude/commands.",
             "This mode is explicit and should be used only when a broader Claude integration surface is intended.",
         ],
         "summary": summary,
@@ -373,6 +460,7 @@ def build_install_mode_summary(result: dict[str, Any]) -> str:
             f"- Routing 文件: {result.get('routing_file', '')}",
             f"- Claude 设置: {result.get('claude_settings', '')}",
             f"- Hook 脚本: {result.get('hook_script', '')}",
+            f"- Slash Commands: {result.get('commands_dir', '')}",
             "- 说明: 可选外部能力如 MemOS 不由 cgc-install 自动写入；如需启用，请在 Claude 中单独配置官方 MCP。",
         ]
         next_actions = [
@@ -391,6 +479,7 @@ def build_install_mode_summary(result: dict[str, Any]) -> str:
             f"- 预演 Settings: {planned.get('settings_json', '')}",
             f"- 预演 MCP: {planned.get('mcp_json', '')}",
             f"- 预演 Hook: {planned.get('hook_script', '')}",
+            f"- 预演 Slash Commands: {planned.get('commands_dir', '')}",
             "- 说明: 该预演只覆盖 CodeCGC 必需执行器；MemOS 等可选外部能力仍建议在 Claude 中独立配置。",
         ]
         next_actions = []
@@ -410,6 +499,7 @@ def build_install_mode_summary(result: dict[str, Any]) -> str:
             f"- Settings: {written.get('settings_json', '')}",
             f"- MCP: {written.get('mcp_json', '')}",
             f"- Hook 脚本: {written.get('hook_script', '')}",
+            f"- Slash Commands: {written.get('commands_dir', '')}",
             "- 说明: 该安装只写入 CodeCGC 必需执行器；MemOS 等可选外部能力仍需在 Claude 中单独配置。",
         ]
         next_actions = [

package/scripts/postinstall_codecgc.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("node:child_process");
+const path = require("node:path");
+
+function shouldRunUserInstall() {
+  const globalFlag = String(process.env.npm_config_global || "").toLowerCase();
+  const localPrefix = String(process.env.npm_config_local_prefix || "");
+  const prefix = String(process.env.npm_config_prefix || "");
+
+  if (globalFlag === "true") {
+    return true;
+  }
+  if (prefix && localPrefix && prefix !== localPrefix) {
+    return true;
+  }
+  return false;
+}
+
+function findPython() {
+  const override = String(process.env.CODECGC_PYTHON_COMMAND || "").trim();
+  const candidates = override
+    ? [override]
+    : (process.platform === "win32" ? ["python", "py"] : ["python3", "python"]);
+
+  for (const command of candidates) {
+    const probe = spawnSync(command, ["--version"], {
+      encoding: "utf8",
+      shell: false,
+    });
+    if (probe.status === 0) {
+      return command;
+    }
+  }
+  return "";
+}
+
+function main() {
+  if (!shouldRunUserInstall()) {
+    return 0;
+  }
+
+  const python = findPython();
+  if (!python) {
+    console.warn("[codecgc] Skipped automatic Claude integration: Python was not found.");
+    console.warn("[codecgc] Run `cgc-install --mode user` after installing Python.");
+    return 0;
+  }
+
+  const repoRoot = path.resolve(__dirname, "..");
+  const installScript = path.join(repoRoot, "scripts", "install_codecgc.py");
+  const result = spawnSync(
+    python,
+    [installScript, "--mode", "user", "--format", "summary"],
+    {
+      cwd: repoRoot,
+      stdio: "inherit",
+      shell: false,
+      env: {
+        ...process.env,
+        PYTHONIOENCODING: process.env.PYTHONIOENCODING || "utf-8",
+        PYTHONUTF8: process.env.PYTHONUTF8 || "1",
+      },
+    },
+  );
+
+  if (result.status !== 0) {
+    console.warn("[codecgc] Automatic Claude integration did not complete during npm install.");
+    console.warn("[codecgc] You can retry manually with `cgc-install --mode user`.");
+  }
+
+  return 0;
+}
+
+process.exit(main());