helloloop 0.2.0 → 0.3.1

package/src/discovery_prompt.mjs

@@ -0,0 +1,298 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+
+import {
+  listDocFilesInDirectory,
+  listProjectCandidatesInDirectory,
+  pathExists,
+  resolveAbsolute,
+} from "./discovery_paths.mjs";
+
+function toDisplayPath(targetPath) {
+  return String(targetPath || "").replaceAll("\\", "/");
+}
+
+export function createDiscoveryPromptSession() {
+  if (process.stdin.isTTY) {
+    const readline = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    return {
+      async question(promptText) {
+        return readline.question(promptText);
+      },
+      close() {
+        readline.close();
+      },
+    };
+  }
+
+  const bufferedAnswers = fs.readFileSync(0, "utf8").split(/\r?\n/);
+  let answerIndex = 0;
+  return {
+    async question(promptText) {
+      process.stdout.write(promptText);
+      const answer = bufferedAnswers[answerIndex] ?? "";
+      answerIndex += 1;
+      return answer;
+    },
+    close() {},
+  };
+}
+
+function summarizeList(items, options = {}) {
+  const limit = Number(options.limit || 12);
+  if (!items.length) {
+    return ["- 无"];
+  }
+
+  const visible = items.slice(0, limit);
+  const lines = visible.map((item) => `- ${item}`);
+  if (items.length > limit) {
+    lines.push(`- 其余 ${items.length - limit} 项未展开`);
+  }
+  return lines;
+}
+
+function collectDirectoryOverview(rootPath) {
+  if (!pathExists(rootPath) || !fs.statSync(rootPath).isDirectory()) {
+    return {
+      rootPath,
+      directories: [],
+      docFiles: [],
+      repoCandidates: [],
+    };
+  }
+
+  const entries = fs.readdirSync(rootPath, { withFileTypes: true });
+  return {
+    rootPath,
+    directories: entries
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort((left, right) => left.localeCompare(right, "zh-CN")),
+    docFiles: listDocFilesInDirectory(rootPath)
+      .map((filePath) => path.basename(filePath))
+      .sort((left, right) => left.localeCompare(right, "zh-CN")),
+    repoCandidates: listProjectCandidatesInDirectory(rootPath)
+      .map((directoryPath) => path.basename(directoryPath))
+      .sort((left, right) => left.localeCompare(right, "zh-CN")),
+  };
+}
+
+function renderDirectoryOverview(title, overview) {
+  return [
+    title,
+    `扫描目录：${toDisplayPath(overview.rootPath)}`,
+    "",
+    "顶层文档文件：",
+    ...summarizeList(overview.docFiles),
+    "",
+    "顶层目录：",
+    ...summarizeList(overview.directories),
+    "",
+    "疑似项目目录：",
+    ...summarizeList(overview.repoCandidates),
+  ].join("\n");
+}
+
+function renderExistingChoices(title, candidates) {
+  return [
+    title,
+    ...candidates.map((item, index) => `${index + 1}. ${toDisplayPath(item)}`),
+    "",
+    "请输入编号；也可以直接输入本地路径；直接回车取消。",
+  ].join("\n");
+}
+
+async function promptForExistingPathSelection(readline, title, candidates, cwd, preface = "") {
+  if (preface) {
+    console.log(preface);
+    console.log("");
+  }
+  console.log(renderExistingChoices(title, candidates));
+  while (true) {
+    const answer = String(await readline.question("> ") || "").trim();
+    if (!answer) {
+      return "";
+    }
+
+    const choiceIndex = Number(answer);
+    if (Number.isInteger(choiceIndex) && choiceIndex >= 1 && choiceIndex <= candidates.length) {
+      return candidates[choiceIndex - 1];
+    }
+
+    const maybePath = resolveAbsolute(answer, cwd);
+    if (pathExists(maybePath)) {
+      return maybePath;
+    }
+
+    console.log("输入无效，请输入候选编号或一个存在的本地路径。");
+  }
+}
+
+async function promptForDocsPath(readline, discovery, cwd) {
+  const docChoices = Array.isArray(discovery.docCandidates) ? discovery.docCandidates : [];
+  const scanRoot = discovery.workspaceRoot || discovery.repoRoot || cwd;
+  const overview = collectDirectoryOverview(scanRoot);
+  const title = docChoices.length
+    ? "请选择开发文档来源："
+    : "未自动识别到明确的开发文档。请输入开发文档目录或文件路径：";
+  const preface = renderDirectoryOverview("当前目录顶层概览", overview);
+
+  if (docChoices.length) {
+    return promptForExistingPathSelection(readline, title, docChoices, cwd, preface);
+  }
+
+  console.log(preface);
+  console.log("");
+  console.log(title);
+  console.log("可直接输入当前目录下的相对路径或绝对路径；直接回车取消。");
+  while (true) {
+    const answer = String(await readline.question("> ") || "").trim();
+    if (!answer) {
+      return "";
+    }
+
+    const maybePath = resolveAbsolute(answer, cwd);
+    if (pathExists(maybePath)) {
+      return maybePath;
+    }
+
+    console.log("路径不存在，请输入一个已存在的开发文档目录或文件路径。");
+  }
+}
+
+async function promptForRepoPath(readline, discovery, cwd) {
+  const repoChoices = Array.isArray(discovery.repoCandidates) ? discovery.repoCandidates : [];
+  const scanRoot = discovery.workspaceRoot
+    || (Array.isArray(discovery.docsEntries) && discovery.docsEntries.length
+      ? path.dirname(discovery.docsEntries[0])
+      : "")
+    || cwd;
+  const overview = collectDirectoryOverview(scanRoot);
+  const preface = renderDirectoryOverview("当前目录顶层概览", overview);
+  const title = repoChoices.length
+    ? "请选择目标项目仓库："
+    : "请输入要开发的项目路径：";
+  console.log(preface);
+  console.log("");
+  if (repoChoices.length) {
+    console.log(renderExistingChoices(title, repoChoices));
+    console.log("也可以直接输入项目路径；如果这是新项目，可输入准备创建的新目录路径。");
+  } else {
+    console.log(title);
+    console.log("如果这是新项目，可直接输入准备创建的新目录路径；直接回车取消。");
+  }
+
+  while (true) {
+    const answer = String(await readline.question("> ") || "").trim();
+    if (!answer) {
+      return { repoRoot: "", allowNewRepoRoot: false };
+    }
+
+    const choiceIndex = Number(answer);
+    if (repoChoices.length && Number.isInteger(choiceIndex) && choiceIndex >= 1 && choiceIndex <= repoChoices.length) {
+      return {
+        repoRoot: repoChoices[choiceIndex - 1],
+        allowNewRepoRoot: false,
+      };
+    }
+
+    const maybePath = resolveAbsolute(answer, cwd);
+    if (pathExists(maybePath) && !fs.statSync(maybePath).isDirectory()) {
+      console.log("项目路径必须是目录，不能是文件。");
+      continue;
+    }
+
+    return {
+      repoRoot: maybePath,
+      allowNewRepoRoot: !pathExists(maybePath),
+    };
+  }
+}
+
+export async function resolveDiscoveryFailureInteractively(
+  failure,
+  options = {},
+  cwd = process.cwd(),
+  allowPrompt = true,
+  sharedPromptSession = null,
+) {
+  const discovery = failure?.discovery || {};
+  const nextOptions = {
+    ...options,
+    selectionSources: {
+      ...(options.selectionSources || {}),
+    },
+  };
+  let changed = false;
+  const promptSession = sharedPromptSession || (allowPrompt ? createDiscoveryPromptSession() : null);
+  const ownsPromptSession = Boolean(promptSession) && !sharedPromptSession;
+
+  try {
+    if (!nextOptions.docsPath) {
+      const docChoices = Array.isArray(discovery.docCandidates) ? discovery.docCandidates : [];
+      if (Array.isArray(discovery.docsEntries) && discovery.docsEntries.length === 1) {
+        nextOptions.docsPath = discovery.docsEntries[0];
+        nextOptions.selectionSources.docs = "workspace_single_doc";
+        changed = true;
+      } else if (docChoices.length === 1) {
+        nextOptions.docsPath = docChoices[0];
+        nextOptions.selectionSources.docs = "workspace_single_doc";
+        changed = true;
+      } else if (failure?.code === "missing_docs" || docChoices.length > 1 || discovery.workspaceRoot) {
+        if (!allowPrompt) {
+          return null;
+        }
+        const selectedDocs = await promptForDocsPath(promptSession, discovery, cwd);
+        if (!selectedDocs) {
+          return null;
+        }
+        nextOptions.docsPath = selectedDocs;
+        nextOptions.selectionSources.docs = "interactive";
+        changed = true;
+        console.log(`已选择开发文档：${toDisplayPath(selectedDocs)}`);
+        console.log("");
+      }
+    }
+
+    const repoChoices = Array.isArray(discovery.repoCandidates) ? discovery.repoCandidates : [];
+    if (!nextOptions.repoRoot && repoChoices.length) {
+      if (repoChoices.length === 1) {
+        nextOptions.repoRoot = repoChoices[0];
+        nextOptions.selectionSources.repo = "workspace_single_repo";
+        changed = true;
+      }
+    }
+
+    if (!nextOptions.repoRoot && failure?.code === "missing_repo") {
+      if (!allowPrompt) {
+        return null;
+      }
+      const selectedRepo = await promptForRepoPath(promptSession, discovery, cwd);
+      if (!selectedRepo.repoRoot) {
+        return null;
+      }
+      nextOptions.repoRoot = selectedRepo.repoRoot;
+      nextOptions.allowNewRepoRoot = selectedRepo.allowNewRepoRoot;
+      nextOptions.selectionSources.repo = selectedRepo.allowNewRepoRoot
+        ? "interactive_new_repo"
+        : "interactive";
+      changed = true;
+      if (selectedRepo.allowNewRepoRoot) {
+        console.log(`已指定项目路径（当前不存在，将按新项目创建）：${toDisplayPath(selectedRepo.repoRoot)}`);
+      } else {
+        console.log(`已选择项目仓库：${toDisplayPath(selectedRepo.repoRoot)}`);
+      }
+      console.log("");
+    }
+    return changed ? nextOptions : null;
+  } finally {
+    if (ownsPromptSession) {
+      promptSession?.close();
+    }
+  }
+}

package/src/install.mjs

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { ensureDir, fileExists, readJson, writeJson } from "./common.mjs";
+import { ensureDir, fileExists, nowIso, readJson, writeJson } from "./common.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -28,6 +28,8 @@ const codexBundleEntries = runtimeBundleEntries.filter((entry) => ![
 ].includes(entry));
 
 const supportedHosts = ["codex", "claude", "gemini"];
+const CLAUDE_MARKETPLACE_NAME = "helloloop-local";
+const CLAUDE_PLUGIN_KEY = "helloloop@helloloop-local";
 
 function resolveHomeDir(homeDir, defaultDirName) {
   return path.resolve(homeDir || path.join(os.homedir(), defaultDirName));
@@ -50,6 +52,14 @@ function removeTargetIfNeeded(targetPath, force) {
   fs.rmSync(targetPath, { recursive: true, force: true });
 }
 
+function removePathIfExists(targetPath) {
+  if (!fileExists(targetPath)) {
+    return false;
+  }
+  fs.rmSync(targetPath, { recursive: true, force: true });
+  return true;
+}
+
 function copyBundleEntries(bundleRoot, targetRoot, entries) {
   for (const entry of entries) {
     const sourcePath = path.join(bundleRoot, entry);
@@ -110,6 +120,23 @@ function updateCodexMarketplace(marketplaceFile) {
   writeJson(marketplaceFile, marketplace);
 }
 
+function removeCodexMarketplaceEntry(marketplaceFile) {
+  if (!fileExists(marketplaceFile)) {
+    return false;
+  }
+
+  const marketplace = readJson(marketplaceFile);
+  const plugins = Array.isArray(marketplace.plugins) ? marketplace.plugins : [];
+  const nextPlugins = plugins.filter((plugin) => plugin?.name !== "helloloop");
+  if (nextPlugins.length === plugins.length) {
+    return false;
+  }
+
+  marketplace.plugins = nextPlugins;
+  writeJson(marketplaceFile, marketplace);
+  return true;
+}
+
 function updateClaudeSettings(settingsFile, marketplaceRoot) {
   const settings = fileExists(settingsFile)
     ? readJson(settingsFile)
@@ -118,15 +145,111 @@ function updateClaudeSettings(settingsFile, marketplaceRoot) {
   settings.extraKnownMarketplaces = settings.extraKnownMarketplaces || {};
   settings.enabledPlugins = settings.enabledPlugins || {};
 
-  settings.extraKnownMarketplaces["helloloop-local"] = {
-    source: "directory",
-    path: marketplaceRoot.replaceAll("\\", "/"),
+  settings.extraKnownMarketplaces[CLAUDE_MARKETPLACE_NAME] = {
+    source: {
+      source: "directory",
+      path: marketplaceRoot,
+    },
   };
-  settings.enabledPlugins["helloloop@helloloop-local"] = true;
+  settings.enabledPlugins[CLAUDE_PLUGIN_KEY] = true;
 
   writeJson(settingsFile, settings);
 }
 
+function removeClaudeSettingsEntries(settingsFile) {
+  if (!fileExists(settingsFile)) {
+    return false;
+  }
+
+  const settings = readJson(settingsFile);
+  let changed = false;
+
+  if (settings.extraKnownMarketplaces && Object.hasOwn(settings.extraKnownMarketplaces, CLAUDE_MARKETPLACE_NAME)) {
+    delete settings.extraKnownMarketplaces[CLAUDE_MARKETPLACE_NAME];
+    changed = true;
+  }
+
+  if (settings.enabledPlugins && Object.hasOwn(settings.enabledPlugins, CLAUDE_PLUGIN_KEY)) {
+    delete settings.enabledPlugins[CLAUDE_PLUGIN_KEY];
+    changed = true;
+  }
+
+  if (changed) {
+    writeJson(settingsFile, settings);
+  }
+  return changed;
+}
+
+function updateClaudeKnownMarketplaces(knownMarketplacesFile, marketplaceRoot, updatedAt) {
+  const knownMarketplaces = fileExists(knownMarketplacesFile)
+    ? readJson(knownMarketplacesFile)
+    : {};
+
+  knownMarketplaces[CLAUDE_MARKETPLACE_NAME] = {
+    source: {
+      source: "directory",
+      path: marketplaceRoot,
+    },
+    installLocation: marketplaceRoot,
+    lastUpdated: updatedAt,
+  };
+
+  writeJson(knownMarketplacesFile, knownMarketplaces);
+}
+
+function removeClaudeKnownMarketplace(knownMarketplacesFile) {
+  if (!fileExists(knownMarketplacesFile)) {
+    return false;
+  }
+
+  const knownMarketplaces = readJson(knownMarketplacesFile);
+  if (!Object.hasOwn(knownMarketplaces, CLAUDE_MARKETPLACE_NAME)) {
+    return false;
+  }
+
+  delete knownMarketplaces[CLAUDE_MARKETPLACE_NAME];
+  writeJson(knownMarketplacesFile, knownMarketplaces);
+  return true;
+}
+
+function updateClaudeInstalledPlugins(installedPluginsFile, pluginRoot, pluginVersion, updatedAt) {
+  const installedPlugins = fileExists(installedPluginsFile)
+    ? readJson(installedPluginsFile)
+    : {
+        version: 2,
+        plugins: {},
+      };
+
+  installedPlugins.version = 2;
+  installedPlugins.plugins = installedPlugins.plugins || {};
+  installedPlugins.plugins[CLAUDE_PLUGIN_KEY] = [
+    {
+      scope: "user",
+      installPath: pluginRoot,
+      version: pluginVersion,
+      installedAt: updatedAt,
+      lastUpdated: updatedAt,
+    },
+  ];
+
+  writeJson(installedPluginsFile, installedPlugins);
+}
+
+function removeClaudeInstalledPlugin(installedPluginsFile) {
+  if (!fileExists(installedPluginsFile)) {
+    return false;
+  }
+
+  const installedPlugins = readJson(installedPluginsFile);
+  if (!installedPlugins.plugins || !Object.hasOwn(installedPlugins.plugins, CLAUDE_PLUGIN_KEY)) {
+    return false;
+  }
+
+  delete installedPlugins.plugins[CLAUDE_PLUGIN_KEY];
+  writeJson(installedPluginsFile, installedPlugins);
+  return true;
+}
+
 function installCodexHost(bundleRoot, options) {
   const resolvedCodexHome = resolveHomeDir(options.codexHome, ".codex");
   const targetPluginsRoot = path.join(resolvedCodexHome, "plugins");
@@ -161,11 +284,34 @@ function installCodexHost(bundleRoot, options) {
   };
 }
 
+function uninstallCodexHost(options) {
+  const resolvedCodexHome = resolveHomeDir(options.codexHome, ".codex");
+  const targetPluginRoot = path.join(resolvedCodexHome, "plugins", "helloloop");
+  const marketplaceFile = path.join(resolvedCodexHome, ".agents", "plugins", "marketplace.json");
+
+  const removedPlugin = removePathIfExists(targetPluginRoot);
+  const removedMarketplace = removeCodexMarketplaceEntry(marketplaceFile);
+
+  return {
+    host: "codex",
+    displayName: "Codex",
+    targetRoot: targetPluginRoot,
+    removed: removedPlugin || removedMarketplace,
+    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 pluginVersion = readJson(sourceManifest).version || readJson(path.join(bundleRoot, "package.json")).version;
+  const targetPluginsRoot = path.join(resolvedClaudeHome, "plugins");
+  const targetMarketplaceRoot = path.join(targetPluginsRoot, "marketplaces", CLAUDE_MARKETPLACE_NAME);
+  const targetCachePluginsRoot = path.join(targetPluginsRoot, "cache", CLAUDE_MARKETPLACE_NAME, "helloloop");
+  const targetInstalledPluginRoot = path.join(targetCachePluginsRoot, pluginVersion);
+  const knownMarketplacesFile = path.join(targetPluginsRoot, "known_marketplaces.json");
+  const installedPluginsFile = path.join(targetPluginsRoot, "installed_plugins.json");
   const settingsFile = path.join(resolvedClaudeHome, "settings.json");
 
   if (!fileExists(sourceManifest)) {
@@ -176,16 +322,55 @@ function installClaudeHost(bundleRoot, options) {
   }
 
   assertPathInside(resolvedClaudeHome, targetMarketplaceRoot, "Claude marketplace 目录");
+  assertPathInside(resolvedClaudeHome, targetInstalledPluginRoot, "Claude 插件缓存目录");
   removeTargetIfNeeded(targetMarketplaceRoot, options.force);
+  removeTargetIfNeeded(targetCachePluginsRoot, options.force);
 
   ensureDir(path.dirname(targetMarketplaceRoot));
+  ensureDir(path.dirname(targetInstalledPluginRoot));
   copyDirectory(sourceMarketplaceRoot, targetMarketplaceRoot);
+  copyDirectory(path.join(sourceMarketplaceRoot, "plugins", "helloloop"), targetInstalledPluginRoot);
+  ensureDir(targetPluginsRoot);
+  const updatedAt = nowIso();
   updateClaudeSettings(settingsFile, targetMarketplaceRoot);
+  updateClaudeKnownMarketplaces(knownMarketplacesFile, targetMarketplaceRoot, updatedAt);
+  updateClaudeInstalledPlugins(installedPluginsFile, targetInstalledPluginRoot, pluginVersion, updatedAt);
+
+  return {
+    host: "claude",
+    displayName: "Claude",
+    targetRoot: targetInstalledPluginRoot,
+    marketplaceFile: path.join(targetMarketplaceRoot, ".claude-plugin", "marketplace.json"),
+    settingsFile,
+  };
+}
+
+function uninstallClaudeHost(options) {
+  const resolvedClaudeHome = resolveHomeDir(options.claudeHome, ".claude");
+  const targetPluginsRoot = path.join(resolvedClaudeHome, "plugins");
+  const targetMarketplaceRoot = path.join(targetPluginsRoot, "marketplaces", CLAUDE_MARKETPLACE_NAME);
+  const targetCachePluginsRoot = path.join(targetPluginsRoot, "cache", CLAUDE_MARKETPLACE_NAME);
+  const knownMarketplacesFile = path.join(targetPluginsRoot, "known_marketplaces.json");
+  const installedPluginsFile = path.join(targetPluginsRoot, "installed_plugins.json");
+  const settingsFile = path.join(resolvedClaudeHome, "settings.json");
+
+  const removedMarketplaceDir = removePathIfExists(targetMarketplaceRoot);
+  const removedCacheDir = removePathIfExists(targetCachePluginsRoot);
+  const removedKnownMarketplace = removeClaudeKnownMarketplace(knownMarketplacesFile);
+  const removedInstalledPlugin = removeClaudeInstalledPlugin(installedPluginsFile);
+  const removedSettingsEntries = removeClaudeSettingsEntries(settingsFile);
 
   return {
     host: "claude",
     displayName: "Claude",
-    targetRoot: path.join(targetMarketplaceRoot, "plugins", "helloloop"),
+    targetRoot: targetCachePluginsRoot,
+    removed: [
+      removedMarketplaceDir,
+      removedCacheDir,
+      removedKnownMarketplace,
+      removedInstalledPlugin,
+      removedSettingsEntries,
+    ].some(Boolean),
     marketplaceFile: path.join(targetMarketplaceRoot, ".claude-plugin", "marketplace.json"),
     settingsFile,
   };
@@ -213,6 +398,18 @@ function installGeminiHost(bundleRoot, options) {
   };
 }
 
+function uninstallGeminiHost(options) {
+  const resolvedGeminiHome = resolveHomeDir(options.geminiHome, ".gemini");
+  const targetExtensionRoot = path.join(resolvedGeminiHome, "extensions", "helloloop");
+
+  return {
+    host: "gemini",
+    displayName: "Gemini",
+    targetRoot: targetExtensionRoot,
+    removed: removePathIfExists(targetExtensionRoot),
+  };
+}
+
 function resolveInstallHosts(hostOption) {
   const normalized = String(hostOption || "codex").trim().toLowerCase();
   if (normalized === "all") {
@@ -242,3 +439,17 @@ export function installPluginBundle(options = {}) {
     marketplaceFile: codexResult?.marketplaceFile || "",
   };
 }
+
+export function uninstallPluginBundle(options = {}) {
+  const selectedHosts = resolveInstallHosts(options.host);
+  const uninstallers = {
+    codex: () => uninstallCodexHost(options),
+    claude: () => uninstallClaudeHost(options),
+    gemini: () => uninstallGeminiHost(options),
+  };
+
+  const uninstalledHosts = selectedHosts.map((host) => uninstallers[host]());
+  return {
+    uninstalledHosts,
+  };
+}