helloloop 0.1.1 → 0.2.0

package/src/install.mjs

@@ -9,9 +9,12 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 export const runtimeBundleEntries = [
+  ".claude-plugin",
   ".codex-plugin",
+  "LICENSE",
   "README.md",
   "bin",
+  "hosts",
   "package.json",
   "scripts",
   "skills",
@@ -19,8 +22,15 @@ export const runtimeBundleEntries = [
   "templates",
 ];
 
-function resolveCodexHome(codexHome) {
-  return path.resolve(codexHome || path.join(os.homedir(), ".codex"));
+const codexBundleEntries = runtimeBundleEntries.filter((entry) => ![
+  ".claude-plugin",
+  "hosts",
+].includes(entry));
+
+const supportedHosts = ["codex", "claude", "gemini"];
+
+function resolveHomeDir(homeDir, defaultDirName) {
+  return path.resolve(homeDir || path.join(os.homedir(), defaultDirName));
 }
 
 function assertPathInside(parentDir, targetDir, label) {
@@ -30,21 +40,38 @@ function assertPathInside(parentDir, targetDir, label) {
   }
 }
 
-function copyBundleEntries(bundleRoot, targetPluginRoot) {
-  for (const entry of runtimeBundleEntries) {
+function removeTargetIfNeeded(targetPath, force) {
+  if (!fileExists(targetPath)) {
+    return;
+  }
+  if (!force) {
+    throw new Error(`目标目录已存在：${targetPath}。若要覆盖，请追加 --force。`);
+  }
+  fs.rmSync(targetPath, { recursive: true, force: true });
+}
+
+function copyBundleEntries(bundleRoot, targetRoot, entries) {
+  for (const entry of entries) {
     const sourcePath = path.join(bundleRoot, entry);
     if (!fileExists(sourcePath)) {
       continue;
     }
 
-    fs.cpSync(sourcePath, path.join(targetPluginRoot, entry), {
+    fs.cpSync(sourcePath, path.join(targetRoot, entry), {
       force: true,
       recursive: true,
     });
   }
 }
 
-function updateMarketplace(marketplaceFile) {
+function copyDirectory(sourceRoot, targetRoot) {
+  fs.cpSync(sourceRoot, targetRoot, {
+    force: true,
+    recursive: true,
+  });
+}
+
+function updateCodexMarketplace(marketplaceFile) {
   const marketplace = fileExists(marketplaceFile)
     ? readJson(marketplaceFile)
     : {
@@ -73,8 +100,6 @@ function updateMarketplace(marketplaceFile) {
     category: "Coding",
   };
 
-  marketplace.plugins = marketplace.plugins.filter((plugin) => plugin?.name !== "autoloop");
-
   const existingIndex = marketplace.plugins.findIndex((plugin) => plugin?.name === "helloloop");
   if (existingIndex >= 0) {
     marketplace.plugins.splice(existingIndex, 1, nextEntry);
@@ -85,35 +110,40 @@ function updateMarketplace(marketplaceFile) {
   writeJson(marketplaceFile, marketplace);
 }
 
-export function installPluginBundle(options = {}) {
-  const bundleRoot = path.resolve(options.bundleRoot || path.join(__dirname, ".."));
-  const resolvedCodexHome = resolveCodexHome(options.codexHome);
+function updateClaudeSettings(settingsFile, marketplaceRoot) {
+  const settings = fileExists(settingsFile)
+    ? readJson(settingsFile)
+    : {};
+
+  settings.extraKnownMarketplaces = settings.extraKnownMarketplaces || {};
+  settings.enabledPlugins = settings.enabledPlugins || {};
+
+  settings.extraKnownMarketplaces["helloloop-local"] = {
+    source: "directory",
+    path: marketplaceRoot.replaceAll("\\", "/"),
+  };
+  settings.enabledPlugins["helloloop@helloloop-local"] = true;
+
+  writeJson(settingsFile, settings);
+}
+
+function installCodexHost(bundleRoot, options) {
+  const resolvedCodexHome = resolveHomeDir(options.codexHome, ".codex");
   const targetPluginsRoot = path.join(resolvedCodexHome, "plugins");
   const targetPluginRoot = path.join(targetPluginsRoot, "helloloop");
-  const legacyPluginRoot = path.join(targetPluginsRoot, "autoloop");
   const marketplaceFile = path.join(resolvedCodexHome, ".agents", "plugins", "marketplace.json");
   const manifestFile = path.join(bundleRoot, ".codex-plugin", "plugin.json");
 
   if (!fileExists(manifestFile)) {
-    throw new Error(`未找到插件 manifest：${manifestFile}`);
+    throw new Error(`未找到 Codex 插件 manifest：${manifestFile}`);
   }
 
-  assertPathInside(resolvedCodexHome, targetPluginRoot, "目标插件目录");
-
-  if (fileExists(targetPluginRoot)) {
-    if (!options.force) {
-      throw new Error(`目标插件目录已存在：${targetPluginRoot}。若要覆盖，请追加 --force。`);
-    }
-    fs.rmSync(targetPluginRoot, { recursive: true, force: true });
-  }
-
-  if (fileExists(legacyPluginRoot)) {
-    fs.rmSync(legacyPluginRoot, { recursive: true, force: true });
-  }
+  assertPathInside(resolvedCodexHome, targetPluginRoot, "Codex 目标插件目录");
+  removeTargetIfNeeded(targetPluginRoot, options.force);
 
   ensureDir(targetPluginsRoot);
   ensureDir(targetPluginRoot);
-  copyBundleEntries(bundleRoot, targetPluginRoot);
+  copyBundleEntries(bundleRoot, targetPluginRoot, codexBundleEntries);
 
   const gitMetadataPath = path.join(targetPluginRoot, ".git");
   if (fileExists(gitMetadataPath)) {
@@ -121,10 +151,94 @@ export function installPluginBundle(options = {}) {
   }
 
   ensureDir(path.dirname(marketplaceFile));
-  updateMarketplace(marketplaceFile);
+  updateCodexMarketplace(marketplaceFile);
 
   return {
-    targetPluginRoot,
+    host: "codex",
+    displayName: "Codex",
+    targetRoot: targetPluginRoot,
     marketplaceFile,
   };
 }
+
+function installClaudeHost(bundleRoot, options) {
+  const resolvedClaudeHome = resolveHomeDir(options.claudeHome, ".claude");
+  const sourceMarketplaceRoot = path.join(bundleRoot, "hosts", "claude", "marketplace");
+  const sourceManifest = path.join(bundleRoot, ".claude-plugin", "plugin.json");
+  const targetMarketplaceRoot = path.join(resolvedClaudeHome, "marketplaces", "helloloop-local");
+  const settingsFile = path.join(resolvedClaudeHome, "settings.json");
+
+  if (!fileExists(sourceManifest)) {
+    throw new Error(`未找到 Claude 插件 manifest：${sourceManifest}`);
+  }
+  if (!fileExists(path.join(sourceMarketplaceRoot, ".claude-plugin", "marketplace.json"))) {
+    throw new Error(`未找到 Claude marketplace 模板：${sourceMarketplaceRoot}`);
+  }
+
+  assertPathInside(resolvedClaudeHome, targetMarketplaceRoot, "Claude marketplace 目录");
+  removeTargetIfNeeded(targetMarketplaceRoot, options.force);
+
+  ensureDir(path.dirname(targetMarketplaceRoot));
+  copyDirectory(sourceMarketplaceRoot, targetMarketplaceRoot);
+  updateClaudeSettings(settingsFile, targetMarketplaceRoot);
+
+  return {
+    host: "claude",
+    displayName: "Claude",
+    targetRoot: path.join(targetMarketplaceRoot, "plugins", "helloloop"),
+    marketplaceFile: path.join(targetMarketplaceRoot, ".claude-plugin", "marketplace.json"),
+    settingsFile,
+  };
+}
+
+function installGeminiHost(bundleRoot, options) {
+  const resolvedGeminiHome = resolveHomeDir(options.geminiHome, ".gemini");
+  const sourceExtensionRoot = path.join(bundleRoot, "hosts", "gemini", "extension");
+  const targetExtensionRoot = path.join(resolvedGeminiHome, "extensions", "helloloop");
+
+  if (!fileExists(path.join(sourceExtensionRoot, "gemini-extension.json"))) {
+    throw new Error(`未找到 Gemini 扩展清单：${sourceExtensionRoot}`);
+  }
+
+  assertPathInside(resolvedGeminiHome, targetExtensionRoot, "Gemini 扩展目录");
+  removeTargetIfNeeded(targetExtensionRoot, options.force);
+
+  ensureDir(path.dirname(targetExtensionRoot));
+  copyDirectory(sourceExtensionRoot, targetExtensionRoot);
+
+  return {
+    host: "gemini",
+    displayName: "Gemini",
+    targetRoot: targetExtensionRoot,
+  };
+}
+
+function resolveInstallHosts(hostOption) {
+  const normalized = String(hostOption || "codex").trim().toLowerCase();
+  if (normalized === "all") {
+    return [...supportedHosts];
+  }
+  if (!supportedHosts.includes(normalized)) {
+    throw new Error(`不支持的宿主：${hostOption}。可选值：codex、claude、gemini、all`);
+  }
+  return [normalized];
+}
+
+export function installPluginBundle(options = {}) {
+  const bundleRoot = path.resolve(options.bundleRoot || path.join(__dirname, ".."));
+  const selectedHosts = resolveInstallHosts(options.host);
+  const installers = {
+    codex: () => installCodexHost(bundleRoot, options),
+    claude: () => installClaudeHost(bundleRoot, options),
+    gemini: () => installGeminiHost(bundleRoot, options),
+  };
+
+  const installedHosts = selectedHosts.map((host) => installers[host]());
+  const codexResult = installedHosts.find((item) => item.host === "codex");
+
+  return {
+    installedHosts,
+    targetPluginRoot: codexResult?.targetRoot || "",
+    marketplaceFile: codexResult?.marketplaceFile || "",
+  };
+}

package/src/process.mjs

@@ -1,8 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 
 import { ensureDir, nowIso, tailText, writeText } from "./common.mjs";
+import { resolveCodexInvocation, resolveVerifyShellInvocation } from "./shell_invocation.mjs";
 
 function runChild(command, args, options = {}) {
   return new Promise((resolve) => {
@@ -51,130 +52,6 @@ function runChild(command, args, options = {}) {
   });
 }
 
-function quoteForCmd(value) {
-  const normalized = String(value ?? "");
-  if (!normalized.length) {
-    return "\"\"";
-  }
-  if (!/[\s"&<>|^]/.test(normalized)) {
-    return normalized;
-  }
-  return `"${normalized.replace(/"/g, "\"\"")}"`;
-}
-
-function buildCmdCommandLine(executable, args) {
-  return [quoteForCmd(executable), ...args.map((item) => quoteForCmd(item))].join(" ");
-}
-
-function hasCommand(command, platform = process.platform) {
-  if (platform === "win32") {
-    const result = spawnSync("where.exe", [command], {
-      encoding: "utf8",
-      shell: false,
-    });
-    return result.status === 0;
-  }
-
-  const result = spawnSync("sh", ["-lc", `command -v ${command}`], {
-    encoding: "utf8",
-    shell: false,
-  });
-  return result.status === 0;
-}
-
-export function resolveVerifyShellInvocation(options = {}) {
-  const platform = options.platform || process.platform;
-  const commandExists = options.commandExists || ((command) => hasCommand(command, platform));
-
-  if (platform === "win32") {
-    if (commandExists("pwsh")) {
-      return {
-        command: "pwsh",
-        argsPrefix: ["-NoLogo", "-NoProfile", "-Command"],
-        shell: false,
-      };
-    }
-
-    if (commandExists("powershell")) {
-      return {
-        command: "powershell",
-        argsPrefix: ["-NoLogo", "-NoProfile", "-Command"],
-        shell: false,
-      };
-    }
-
-    return {
-      command: "cmd.exe",
-      argsPrefix: ["/d", "/s", "/c"],
-      shell: false,
-    };
-  }
-
-  return {
-    command: "sh",
-    argsPrefix: ["-lc"],
-    shell: false,
-  };
-}
-
-function resolveCodexExecutable(explicitExecutable = "") {
-  if (explicitExecutable) {
-    return explicitExecutable;
-  }
-
-  if (process.platform !== "win32") {
-    return "codex";
-  }
-
-  const candidates = ["codex.cmd", "codex", "codex.ps1"];
-  for (const candidate of candidates) {
-    const result = spawnSync("where.exe", [candidate], {
-      encoding: "utf8",
-      shell: false,
-    });
-    if (result.status !== 0) {
-      continue;
-    }
-
-    const firstLine = String(result.stdout || "")
-      .split(/\r?\n/)
-      .map((line) => line.trim())
-      .find(Boolean);
-    if (firstLine) {
-      return firstLine;
-    }
-  }
-
-  return "codex";
-}
-
-function resolveCodexInvocation(explicitExecutable = "") {
-  const executable = resolveCodexExecutable(explicitExecutable);
-
-  if (process.platform === "win32" && /\.ps1$/i.test(executable)) {
-    return {
-      command: "pwsh",
-      argsPrefix: ["-NoLogo", "-NoProfile", "-File", executable],
-      shell: false,
-    };
-  }
-
-  if (process.platform === "win32" && /\.(cmd|bat)$/i.test(executable)) {
-    return {
-      command: "cmd.exe",
-      argsPrefix: ["/d", "/s", "/c"],
-      executable,
-      shell: false,
-    };
-  }
-
-  return {
-    command: executable,
-    argsPrefix: [],
-    shell: false,
-  };
-}
-
 function writeCodexRunArtifacts(runDir, prefix, result, finalMessage) {
   writeText(path.join(runDir, `${prefix}-stdout.log`), result.stdout);
   writeText(path.join(runDir, `${prefix}-stderr.log`), result.stderr);
@@ -205,7 +82,7 @@ export async function runCodexTask({
   ensureDir(runDir);
 
   const lastMessageFile = path.join(runDir, `${outputPrefix}-last-message.txt`);
-  const invocation = resolveCodexInvocation(executable);
+  const invocation = resolveCodexInvocation({ explicitExecutable: executable });
   const codexArgs = ["exec", "-C", context.repoRoot];
 
   if (model) {
@@ -230,9 +107,19 @@ export async function runCodexTask({
   }
   codexArgs.push("-o", lastMessageFile, "-");
 
-  const args = invocation.executable
-    ? [...invocation.argsPrefix, buildCmdCommandLine(invocation.executable, codexArgs)]
-    : [...invocation.argsPrefix, ...codexArgs];
+  if (invocation.error) {
+    const result = {
+      ok: false,
+      code: 1,
+      stdout: "",
+      stderr: invocation.error,
+    };
+    writeText(path.join(runDir, `${outputPrefix}-prompt.md`), prompt);
+    writeCodexRunArtifacts(runDir, outputPrefix, result, "");
+    return { ...result, finalMessage: "" };
+  }
+
+  const args = [...invocation.argsPrefix, ...codexArgs];
 
   const result = await runChild(invocation.command, args, {
     cwd: context.repoRoot,
@@ -266,6 +153,21 @@ export async function runCodexExec({ context, prompt, runDir, policy }) {
 
 export async function runShellCommand(context, commandLine, runDir, index) {
   const shellInvocation = resolveVerifyShellInvocation();
+  if (shellInvocation.error) {
+    const result = {
+      command: commandLine,
+      ok: false,
+      code: 1,
+      stdout: "",
+      stderr: shellInvocation.error,
+    };
+    const prefix = String(index + 1).padStart(2, "0");
+    writeText(path.join(runDir, `${prefix}-verify-command.txt`), commandLine);
+    writeText(path.join(runDir, `${prefix}-verify-stdout.log`), result.stdout);
+    writeText(path.join(runDir, `${prefix}-verify-stderr.log`), result.stderr);
+    return result;
+  }
+
   const result = await runChild(shellInvocation.command, [
     ...shellInvocation.argsPrefix,
     commandLine,

package/src/prompt.mjs

@@ -1,4 +1,9 @@
 import { formatList } from "./common.mjs";
+import {
+  hasCustomProjectConstraints,
+  listMandatoryGuardrails,
+  resolveProjectConstraints,
+} from "./guardrails.mjs";
 
 function normalizeDocEntry(doc) {
   return String(doc || "").trim().replaceAll("\\", "/");
@@ -63,17 +68,9 @@ export function buildTaskPrompt({
     ...requiredDocs,
     ...(task.docs || []),
   ]);
-
-  const effectiveConstraints = constraints.length
-    ? constraints
-    : [
-        "所有文件修改必须用 apply_patch。",
-        "不得通过压缩代码、删空行、缩短命名来压行数。",
-        "Rust / TS / TSX / Vue / Python / Go 单文件强制拆分上限 400 行。",
-        "新增可见文案必须同时补齐 zh-CN 与 en-US。",
-        "完成后必须同步相关中文文档与联调文档。",
-        "完成前必须主动运行验证，不要停在分析层。",
-      ];
+  const mandatoryGuardrails = listMandatoryGuardrails();
+  const effectiveConstraints = resolveProjectConstraints(constraints);
+  const usingFallbackConstraints = !hasCustomProjectConstraints(constraints);
 
   return [
     "你在本地仓库中执行一个连续开发任务。",
@@ -95,7 +92,8 @@ export function buildTaskPrompt({
     ].join("\n")),
     listSection("涉及路径", task.paths || []),
     listSection("验收条件", task.acceptance || []),
-    listSection("实现约束", effectiveConstraints),
+    listSection("内建安全底线", mandatoryGuardrails),
+    listSection(usingFallbackConstraints ? "默认工程约束（文档未明确时生效）" : "项目/用户约束", effectiveConstraints),
     repoStateText ? section("仓库当前状态", repoStateText) : "",
     failureHistory.length
       ? section("已失败尝试摘要", failureHistory.slice(-4).map((item) => (

package/src/shell_invocation.mjs

@@ -0,0 +1,225 @@
+import { spawnSync } from "node:child_process";
+
+function createUnavailableInvocation(message) {
+  return {
+    command: "",
+    argsPrefix: [],
+    shell: false,
+    error: message,
+  };
+}
+
+function parseWindowsCommandMatches(output) {
+  return String(output || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function hasCommand(command, platform = process.platform) {
+  if (platform === "win32") {
+    const result = spawnSync("where.exe", [command], {
+      encoding: "utf8",
+      shell: false,
+    });
+    return result.status === 0;
+  }
+
+  const result = spawnSync("sh", ["-lc", `command -v ${command}`], {
+    encoding: "utf8",
+    shell: false,
+  });
+  return result.status === 0;
+}
+
+function findWindowsCommandPaths(command, resolver) {
+  const lookup = resolver || ((name) => {
+    const result = spawnSync("where.exe", [name], {
+      encoding: "utf8",
+      shell: false,
+    });
+    return result.status === 0 ? parseWindowsCommandMatches(result.stdout) : [];
+  });
+
+  return lookup(command);
+}
+
+function resolveWindowsPowerShellHost(options = {}) {
+  const commandExists = options.commandExists || ((command) => hasCommand(command, "win32"));
+
+  if (commandExists("pwsh")) {
+    return {
+      command: "pwsh",
+      shell: false,
+    };
+  }
+
+  if (commandExists("powershell")) {
+    return {
+      command: "powershell",
+      shell: false,
+    };
+  }
+
+  return null;
+}
+
+function resolveWindowsCommandShell(options = {}) {
+  const commandExists = options.commandExists || ((command) => hasCommand(command, "win32"));
+  const preferredHosts = [
+    {
+      check: "pwsh",
+      invocation: {
+        command: "pwsh",
+        argsPrefix: ["-NoLogo", "-NoProfile", "-Command"],
+        shell: false,
+      },
+    },
+    {
+      check: "bash",
+      invocation: {
+        command: "bash",
+        argsPrefix: ["-lc"],
+        shell: false,
+      },
+    },
+    {
+      check: "powershell",
+      invocation: {
+        command: "powershell",
+        argsPrefix: ["-NoLogo", "-NoProfile", "-Command"],
+        shell: false,
+      },
+    },
+  ];
+
+  for (const host of preferredHosts) {
+    if (commandExists(host.check)) {
+      return host.invocation;
+    }
+  }
+
+  return null;
+}
+
+function resolvePosixCommandShell(options = {}) {
+  const platform = options.platform || process.platform;
+  const commandExists = options.commandExists || ((command) => hasCommand(command, platform));
+
+  if (commandExists("bash")) {
+    return {
+      command: "bash",
+      argsPrefix: ["-lc"],
+      shell: false,
+    };
+  }
+
+  return {
+    command: "sh",
+    argsPrefix: ["-lc"],
+    shell: false,
+  };
+}
+
+function isCmdLikeExecutable(executable) {
+  return /\.(cmd|bat)$/i.test(String(executable || ""));
+}
+
+function resolveWindowsNamedExecutable(toolName, options = {}) {
+  const explicitExecutable = String(options.explicitExecutable || "").trim();
+  const findCommandPaths = options.findCommandPaths || ((command) => findWindowsCommandPaths(command));
+
+  if (explicitExecutable) {
+    return explicitExecutable;
+  }
+
+  const searchOrder = [`${toolName}.ps1`, `${toolName}.exe`, toolName];
+  for (const query of searchOrder) {
+    const safeMatch = findCommandPaths(query).find((candidate) => !isCmdLikeExecutable(candidate));
+    if (safeMatch) {
+      return safeMatch;
+    }
+  }
+
+  return "";
+}
+
+export function resolveVerifyShellInvocation(options = {}) {
+  const platform = options.platform || process.platform;
+
+  if (platform === "win32") {
+    const host = resolveWindowsCommandShell(options);
+    if (!host) {
+      return createUnavailableInvocation(
+        "Windows 环境需要 pwsh、bash（如 Git Bash）或 powershell 才能安全执行验证命令；HelloLoop 已禁止回退到 cmd.exe。",
+      );
+    }
+    return host;
+  }
+
+  return resolvePosixCommandShell(options);
+}
+
+export function resolveCliInvocation(options = {}) {
+  const platform = options.platform || process.platform;
+  const explicitExecutable = String(options.explicitExecutable || "").trim();
+  const commandName = String(options.commandName || "").trim();
+  const toolDisplayName = String(options.toolDisplayName || commandName || "CLI");
+
+  if (!commandName && !explicitExecutable) {
+    return createUnavailableInvocation("未提供 CLI 名称或显式可执行路径。");
+  }
+
+  if (platform !== "win32") {
+    return {
+      command: explicitExecutable || commandName,
+      argsPrefix: [],
+      shell: false,
+    };
+  }
+
+  const executable = resolveWindowsNamedExecutable(commandName, {
+    explicitExecutable,
+    findCommandPaths: options.findCommandPaths,
+  });
+  if (!executable) {
+    return createUnavailableInvocation(
+      `未找到可安全执行的 ${toolDisplayName} 入口。Windows 环境需要 ${commandName}.ps1、${commandName}.exe 或其他非 cmd 的可执行入口。`,
+    );
+  }
+
+  if (isCmdLikeExecutable(executable)) {
+    return createUnavailableInvocation(
+      `HelloLoop 在 Windows 已禁止通过 cmd/bat 启动 ${toolDisplayName}：${executable}`,
+    );
+  }
+
+  if (/\.ps1$/i.test(executable)) {
+    const host = resolveWindowsPowerShellHost(options);
+    if (!host) {
+      return createUnavailableInvocation(
+        `需要 pwsh 或 powershell 才能安全执行 ${executable}；HelloLoop 不会回退到 cmd.exe。`,
+      );
+    }
+
+    return {
+      command: host.command,
+      argsPrefix: ["-NoLogo", "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", executable],
+      shell: host.shell,
+    };
+  }
+
+  return {
+    command: executable,
+    argsPrefix: [],
+    shell: false,
+  };
+}
+
+export function resolveCodexInvocation(options = {}) {
+  return resolveCliInvocation({
+    ...options,
+    commandName: "codex",
+    toolDisplayName: "Codex",
+  });
+}