helloloop 0.2.1 → 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

@@ -52,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);
@@ -112,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)
@@ -131,6 +156,30 @@ function updateClaudeSettings(settingsFile, marketplaceRoot) {
   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)
@@ -148,6 +197,21 @@ function updateClaudeKnownMarketplaces(knownMarketplacesFile, marketplaceRoot, u
   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)
@@ -171,6 +235,21 @@ function updateClaudeInstalledPlugins(installedPluginsFile, pluginRoot, pluginVe
   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");
@@ -205,6 +284,23 @@ 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");
@@ -249,6 +345,37 @@ function installClaudeHost(bundleRoot, options) {
   };
 }
 
+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: targetCachePluginsRoot,
+    removed: [
+      removedMarketplaceDir,
+      removedCacheDir,
+      removedKnownMarketplace,
+      removedInstalledPlugin,
+      removedSettingsEntries,
+    ].some(Boolean),
+    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");
@@ -271,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") {
@@ -300,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,
+  };
+}

package/src/rebuild.mjs

@@ -0,0 +1,116 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { ensureDir, nowIso, writeJson } from "./common.mjs";
+
+const PROTECTED_TOP_LEVEL = new Set([
+  ".git",
+  ".gitignore",
+  ".gitattributes",
+  ".helloagents",
+  ".helloloop",
+]);
+
+function ensureSafeRepoRoot(repoRoot) {
+  const absoluteRepoRoot = path.resolve(repoRoot);
+  const parsed = path.parse(absoluteRepoRoot);
+  if (absoluteRepoRoot === parsed.root) {
+    throw new Error(`拒绝清理根目录：${absoluteRepoRoot}`);
+  }
+  if (!fs.existsSync(absoluteRepoRoot) || !fs.statSync(absoluteRepoRoot).isDirectory()) {
+    throw new Error(`项目目录不存在或不是目录：${absoluteRepoRoot}`);
+  }
+}
+
+function collectDocsInsideRepo(repoRoot, discovery) {
+  const resolvedDocs = Array.isArray(discovery?.resolvedDocs) ? discovery.resolvedDocs : [];
+  return resolvedDocs
+    .map((item) => ({
+      absolutePath: path.resolve(item.absolutePath),
+      relativePath: String(item.relativePath || "").replaceAll("\\", "/"),
+    }))
+    .filter((item) => {
+      const relative = path.relative(repoRoot, item.absolutePath);
+      return relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+    });
+}
+
+function stagePreservedDocs(configRoot, docs) {
+  const stageRoot = path.join(configRoot, "rebuild-staging", nowIso().replaceAll(":", "-").replaceAll(".", "-"));
+  for (const doc of docs) {
+    const stagedTarget = path.join(stageRoot, doc.relativePath);
+    ensureDir(path.dirname(stagedTarget));
+    fs.copyFileSync(doc.absolutePath, stagedTarget);
+  }
+  return stageRoot;
+}
+
+function removeUnprotectedTopLevel(repoRoot) {
+  const removedEntries = [];
+  for (const entry of fs.readdirSync(repoRoot, { withFileTypes: true })) {
+    if (PROTECTED_TOP_LEVEL.has(entry.name)) {
+      continue;
+    }
+
+    const entryPath = path.join(repoRoot, entry.name);
+    fs.rmSync(entryPath, { recursive: true, force: true });
+    removedEntries.push(entry.name);
+  }
+  return removedEntries;
+}
+
+function restoreDocsFromStage(repoRoot, stageRoot, docs) {
+  for (const doc of docs) {
+    const stagedSource = path.join(stageRoot, doc.relativePath);
+    const targetPath = path.join(repoRoot, doc.relativePath);
+    ensureDir(path.dirname(targetPath));
+    fs.copyFileSync(stagedSource, targetPath);
+  }
+}
+
+function resetLoopRuntime(context) {
+  for (const target of [
+    context.backlogFile,
+    context.projectFile,
+    context.statusFile,
+    context.stateFile,
+  ]) {
+    if (fs.existsSync(target)) {
+      fs.rmSync(target, { recursive: true, force: true });
+    }
+  }
+
+  if (fs.existsSync(context.runsDir)) {
+    fs.rmSync(context.runsDir, { recursive: true, force: true });
+  }
+}
+
+export function resetRepoForRebuild(context, discovery) {
+  ensureSafeRepoRoot(context.repoRoot);
+
+  const preservedDocs = collectDocsInsideRepo(context.repoRoot, discovery);
+  const stageRoot = preservedDocs.length
+    ? stagePreservedDocs(context.configRoot, preservedDocs)
+    : "";
+
+  const manifestFile = path.join(context.configRoot, "rebuild-manifest.json");
+  const removedEntries = removeUnprotectedTopLevel(context.repoRoot);
+  resetLoopRuntime(context);
+
+  if (stageRoot) {
+    restoreDocsFromStage(context.repoRoot, stageRoot, preservedDocs);
+  }
+
+  writeJson(manifestFile, {
+    updatedAt: nowIso(),
+    repoRoot: context.repoRoot,
+    removedEntries,
+    preservedDocs: preservedDocs.map((item) => item.relativePath),
+  });
+
+  return {
+    removedEntries,
+    preservedDocs: preservedDocs.map((item) => item.relativePath),
+    manifestFile,
+  };
+}

package/templates/analysis-output.schema.json

@@ -50,6 +50,64 @@
         "type": "string"
       }
     },
+    "requestInterpretation": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "summary",
+        "priorities",
+        "cautions"
+      ],
+      "properties": {
+        "summary": {
+          "type": "string",
+          "minLength": 1
+        },
+        "priorities": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "cautions": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "repoDecision": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "compatibility",
+        "action",
+        "reason"
+      ],
+      "properties": {
+        "compatibility": {
+          "type": "string",
+          "enum": [
+            "compatible",
+            "conflict",
+            "uncertain"
+          ]
+        },
+        "action": {
+          "type": "string",
+          "enum": [
+            "continue_existing",
+            "confirm_rebuild",
+            "start_new"
+          ]
+        },
+        "reason": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
     "tasks": {
       "type": "array",
       "minItems": 1,