harness-everything 0.2.0

package/scripts/lib/advisory-text.js

@@ -0,0 +1,163 @@
+// Prompt-injection-only guidance for platforms with no hook/execution
+// mechanism (Cursor, Copilot, Codex, Continue, Hermes). Single source of
+// truth for the advisory block - it used to be duplicated verbatim inside
+// installer.js's top level and again inside main().
+const fs = require('fs');
+const path = require('path');
+
+const MARKER = "Harness OS Guidance (Advisory)";
+
+const advisoryInstructions = [
+  `\n# ${MARKER}`,
+  `This file is advisory only - this platform has no hook/execution mechanism to`,
+  `enforce it mechanically (unlike Claude Code's hook-based circuit breaker). Treat`,
+  `these as strong defaults, not guarantees.`,
+  ``,
+  `## 🚦 MANDATORY ENTRY TRIAGE & ROUTING (ALWAYS RUN FIRST)`,
+  `Every time you receive a new prompt, you MUST load the \`harness-everything\` skill and immediately do the following:`,
+  `1. Run the Tier Router script: \`node harness-everything/scripts/tier-router.js "<Brief summary of user's prompt>"\` (or simulate its routing logic if terminal is not initialized yet).`,
+  `2. Output a clear, stylized routing checkpoint block at the VERY BEGINNING of your response to the user:`,
+  `   \`\`\`markdown`,
+  `   ## 🚦 Harness OS Routing Checkpoint`,
+  `   - **Active Tier**: Tier 1 (Trivial) | Tier 2 (Standard) | Tier 3 (Macro)`,
+  `   - **Rationale**: <1-sentence rationale from the tier router output>`,
+  `   - **Routed Skills, Guides & Actions**:`,
+  `     - \`path/to/skill/or/guide.md\` (<Brief reason why this guide/skill is loaded/used>)`,
+  `   \`\`\``,
+  ``,
+  `## 🤖 COGNITIVE COMPLIANCE (NO SILENT DEGRADES FOR NEW FEATURES)`,
+  `- **Newly Added Features / Extensions**: Copilot is highly prone to treating new feature requests as Tier 1 direct edits. If a task introduces *any* new logic, a new API endpoint, or a new file/module, you **MUST NOT** treat it as Tier 1. It **MUST** be treated as a **Tier 2 (Standard Task)** or **Tier 3 (Macro Task)**.`,
+  `- **Tier 2 Activation**: Initialize the \`todo-driven-workflow\` checklist first. Summon Domain Experts based on tech stack. Load and execute the \`tdd\` (Test-Driven Development) skill (write tests first, implement, refactor).`,
+  `- **Tier 3 Activation**: Initialize the \`todo-driven-workflow\` checklist, load \`fable-mode\` and \`fable-discipline\`, run sub-agents via \`create-agent-launcher\`, and write global docs using \`repo-docs\`.`,
+  `- **Memory Summarization (Self-Evolve)**: Upon task completion, you **MUST** run the \`self-evolve\` skill (running \`node self-evolve/scripts/self-regression.js\` or writing memories) to record key insights, lessons learned, and error boundaries so your context builds across sessions.`,
+  `- **Environment Discovery**: Discover the environment (OS, shell, package manager) before running commands - don't assume.`,
+  `- **Rule of 3**: If the same error repeats 3 times in a row, STOP retrying. Explain what's failing and ask the human for direction instead of continuing to guess.`,
+  `- **Prefer Editing**: Prefer editing over rewriting; commit logically complete chunks rather than one giant diff.`,
+  ``
+].join('\n');
+
+function injectAdvisoryText(targetFile, header, label) {
+  const dir = path.dirname(targetFile);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+  if (fs.existsSync(targetFile)) {
+    const content = fs.readFileSync(targetFile, 'utf8');
+    if (!content.includes(MARKER)) {
+      fs.appendFileSync(targetFile, advisoryInstructions, 'utf8');
+      console.log(`  ✅ Augmented existing ${label} with Harness guidance (advisory-only)`);
+    }
+  } else {
+    fs.writeFileSync(targetFile, `${header}\n${advisoryInstructions}`, 'utf8');
+    console.log(`  ✅ Created ${label} with Harness guidance (advisory-only)`);
+  }
+}
+
+function removeAdvisoryText(targetFile) {
+  if (!fs.existsSync(targetFile)) return;
+  try {
+    let content = fs.readFileSync(targetFile, 'utf8');
+    const markerIndex = content.indexOf(MARKER);
+    if (markerIndex !== -1) {
+      let cleanContent = content;
+      const hashMarkerIndex = content.lastIndexOf('#', markerIndex);
+      if (hashMarkerIndex !== -1) {
+        cleanContent = content.substring(0, hashMarkerIndex).trim() + '\n';
+      } else {
+        cleanContent = content.substring(0, markerIndex).trim() + '\n';
+      }
+
+      const lines = cleanContent.trim().split('\n').map(l => l.trim()).filter(l => l !== '');
+      if (lines.length === 0 || (lines.length === 1 && (lines[0] === '# Cursor Project Rules' || lines[0] === '# AGENTS.md' || lines[0] === '# Copilot Instructions' || lines[0] === '# .hermes.md'))) {
+        fs.unlinkSync(targetFile);
+        console.log(`  ✅ Removed empty advisory file: ${targetFile}`);
+      } else {
+        fs.writeFileSync(targetFile, cleanContent.trim() + '\n', 'utf8');
+        console.log(`  ✅ Removed Harness guidance from: ${targetFile}`);
+      }
+    }
+  } catch (e) {
+    console.warn(`  ⚠️ Error removing advisory text from ${targetFile}: ${e.message}`);
+  }
+}
+
+// Continue.dev reads project rules as individual Markdown files (with YAML
+// frontmatter) from a `.continue/rules/` folder rather than one shared file,
+// so - unlike the shared-file platforms above - Harness gets its own
+// dedicated `harness.md` rule file instead of appending into an arbitrary
+// pre-existing one.
+function installContinueRule(targetFile, label) {
+  const dir = path.dirname(targetFile);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  if (fs.existsSync(targetFile) && fs.readFileSync(targetFile, 'utf8').includes(MARKER)) {
+    return;
+  }
+  const content = [
+    `---`,
+    `name: Harness OS Guidance`,
+    `alwaysApply: true`,
+    `description: "Harness OS routing, circuit-breaker awareness, and environment-discovery guidance (advisory only on Continue - no hook mechanism)"`,
+    `---`,
+    advisoryInstructions.replace(/^\n/, '')
+  ].join('\n');
+  fs.writeFileSync(targetFile, content, 'utf8');
+  console.log(`  ✅ Installed Continue rule file with Harness guidance (advisory-only): ${label}`);
+}
+
+function removeContinueRule(targetFile) {
+  if (!fs.existsSync(targetFile)) return;
+  try {
+    const content = fs.readFileSync(targetFile, 'utf8');
+    if (content.includes(MARKER)) {
+      fs.unlinkSync(targetFile);
+      console.log(`  ✅ Removed Harness rule file: ${targetFile}`);
+    }
+  } catch (e) {
+    console.warn(`  ⚠️ Error removing ${targetFile}: ${e.message}`);
+  }
+}
+
+function buildCopilotGlobalContent() {
+  return [
+    `---`,
+    `description: "Harness OS Guidance (Advisory)"`,
+    `applyTo: "**"`,
+    `---`,
+    `# Copilot Instructions`,
+    ``,
+    advisoryInstructions.replace(/^\n/, '')
+  ].join('\n');
+}
+
+function buildCodexGlobalContent() {
+  return [
+    `---`,
+    `description: "Harness OS Guidance - Global custom agent for orchestrating multi-agent workflows"`,
+    `name: "Harness"`,
+    `user-invocable: true`,
+    `---`,
+    `# AGENTS.md`,
+    ``,
+    `This file is advisory only - this platform has no hook/execution mechanism to`,
+    `enforce it mechanically (unlike Claude Code's hook-based circuit breaker). Treat`,
+    `these as strong defaults, not guarantees.`,
+    ``,
+    `- Discover the environment (OS, shell, package manager) before running commands - don't assume.`,
+    `- Triage tasks: trivial fixes need no plan; standard features need tests; large refactors need`,
+    `  an explicit plan reviewed with the human before implementation.`,
+    `- If the same error repeats 3 times in a row, STOP retrying. Explain what's failing and ask the`,
+    `  human for direction instead of continuing to guess.`,
+    `- Prefer editing over rewriting; commit logically complete chunks rather than one giant diff.`,
+    ``
+  ].join('\n');
+}
+
+module.exports = {
+  MARKER,
+  advisoryInstructions,
+  injectAdvisoryText,
+  removeAdvisoryText,
+  installContinueRule,
+  removeContinueRule,
+  buildCopilotGlobalContent,
+  buildCodexGlobalContent,
+};

package/scripts/lib/claude-hooks.js

@@ -0,0 +1,71 @@
+// Merge/remove Harness's hook entries in a Claude Code settings.json without
+// disturbing anything else a user (or another tool) put there.
+const fs = require('fs');
+
+// Every hook this package ships is namespaced "harness:<phase>:<name>" (see
+// hooks/hooks.json) specifically so removal can match on that prefix alone -
+// never on loose text like "does the command mention harness", which could
+// false-positive on someone else's unrelated hook (e.g. a script whose path
+// or name happens to contain "harness").
+function isHarnessHook(hook) {
+  return !!(hook && hook.id && hook.id.startsWith('harness:'));
+}
+
+function mergeHarnessHooks(claudeConfig, resolvedHooks) {
+  claudeConfig.hooks = claudeConfig.hooks || {};
+  for (const [hookType, hookList] of Object.entries(resolvedHooks)) {
+    const existingList = claudeConfig.hooks[hookType] || [];
+    const mergedList = [...existingList];
+    hookList.forEach(newHook => {
+      const existsIdx = mergedList.findIndex(h => h.id === newHook.id);
+      if (existsIdx !== -1) {
+        mergedList[existsIdx] = newHook;
+      } else {
+        mergedList.push(newHook);
+      }
+    });
+    claudeConfig.hooks[hookType] = mergedList;
+  }
+  return claudeConfig;
+}
+
+function removeHarnessHooks(claudeSettingsFile) {
+  if (!fs.existsSync(claudeSettingsFile)) return false;
+  try {
+    const content = fs.readFileSync(claudeSettingsFile, 'utf8');
+    let config = JSON.parse(content);
+    if (!config.hooks) return false;
+
+    let modified = false;
+    for (const [hookType, hookList] of Object.entries(config.hooks)) {
+      if (!Array.isArray(hookList)) continue;
+      const originalLength = hookList.length;
+      config.hooks[hookType] = hookList.filter(hook => !isHarnessHook(hook));
+      if (config.hooks[hookType].length !== originalLength) {
+        modified = true;
+      }
+      if (config.hooks[hookType].length === 0) {
+        delete config.hooks[hookType];
+      }
+    }
+    if (Object.keys(config.hooks || {}).length === 0) {
+      delete config.hooks;
+    }
+
+    if (modified) {
+      if (Object.keys(config).length === 0) {
+        fs.unlinkSync(claudeSettingsFile);
+        console.log(`  ✅ Cleaned up and removed empty Claude settings file: ${claudeSettingsFile}`);
+      } else {
+        fs.writeFileSync(claudeSettingsFile, JSON.stringify(config, null, 2), 'utf8');
+        console.log(`  ✅ Safely removed Harness hooks from Claude settings: ${claudeSettingsFile}`);
+      }
+      return true;
+    }
+  } catch (e) {
+    console.warn(`  ⚠️ Error cleaning Claude settings file ${claudeSettingsFile}: ${e.message}`);
+  }
+  return false;
+}
+
+module.exports = { isHarnessHook, mergeHarnessHooks, removeHarnessHooks };

package/scripts/lib/gitignore.js

@@ -0,0 +1,58 @@
+const fs = require('fs');
+const path = require('path');
+
+function ensureWorkspaceGitignorePatterns(wsRoot, patterns) {
+  const gitignorePath = path.join(wsRoot, '.gitignore');
+  try {
+    let content = '';
+    if (fs.existsSync(gitignorePath)) {
+      content = fs.readFileSync(gitignorePath, 'utf8');
+    }
+
+    const lines = content.split(/\r?\n/);
+    const addedPatterns = [];
+
+    for (const pattern of patterns) {
+      const isIgnored = lines.some(line => {
+        const trimmed = line.trim();
+        return trimmed === pattern ||
+               trimmed === pattern.slice(0, -1) ||
+               (pattern === '.claude/harness-state/' && (trimmed === '.claude/' || trimmed === '.claude'));
+      });
+
+      if (!isIgnored) {
+        addedPatterns.push(pattern);
+      }
+    }
+
+    if (addedPatterns.length > 0) {
+      const separator = content.length === 0 || content.endsWith('\n') ? '' : '\n';
+      const toAppend = addedPatterns.join('\n') + '\n';
+      fs.appendFileSync(gitignorePath, `${separator}${toAppend}`, 'utf8');
+      console.log(`  ✅ Added auto-generated directories to .gitignore: ${addedPatterns.join(', ')}`);
+    }
+  } catch (err) {
+    console.warn(`  ⚠️ Failed to update .gitignore: ${err.message}`);
+  }
+}
+
+// Only ever deletes a directory that is genuinely empty, and never recurses
+// past one of `stopDirs` (workspace root / user home / filesystem root) - so
+// this can only ever tidy up directories Harness itself just emptied out,
+// never reach into a parent that still holds unrelated content.
+function cleanEmptyDirs(dir, stopDirs) {
+  if (!fs.existsSync(dir)) return;
+  if ((stopDirs || []).includes(dir) || dir === path.parse(dir).root) return;
+  try {
+    const files = fs.readdirSync(dir);
+    if (files.length === 0) {
+      fs.rmdirSync(dir);
+      console.log(`  ✅ Cleaned up empty directory: ${dir}`);
+      cleanEmptyDirs(path.dirname(dir), stopDirs);
+    }
+  } catch (e) {
+    // ignore
+  }
+}
+
+module.exports = { ensureWorkspaceGitignorePatterns, cleanEmptyDirs };

package/scripts/lib/manifest.js

@@ -0,0 +1,82 @@
+// Tracks exactly what this package installed, so uninstall can remove
+// precisely those paths instead of sweeping shared directories that may also
+// hold content from other tools, the user's own manual additions, or
+// self-evolve's locally-generated skills.
+//
+// The manifest always lives at <platform-home>/harness-everything/manifest.json
+// - e.g. .claude/harness-everything/manifest.json, .cursor/harness-everything/
+// manifest.json, or (global scope) ~/.agents/harness-everything/manifest.json.
+// harness-everything/ is a subfolder this package exclusively owns inside a
+// directory that already belongs to that platform (or, for global scope, the
+// shared ~/.agents convention) - nothing else creates a directory literally
+// named "harness-everything" there, so nesting under it is what makes "the
+// manifest can only describe our own installs" actually true.
+const fs = require('fs');
+const path = require('path');
+
+const PACKAGE_NAME = 'harness-everything';
+const HARNESS_AUTHOR = 'Miya Daniel | Harness Core Team';
+const HARNESS_DIR_NAME = 'harness-everything';
+
+function getHarnessDir(homeDir) {
+  return path.join(homeDir, HARNESS_DIR_NAME);
+}
+
+function getManifestPath(homeDir) {
+  return path.join(getHarnessDir(homeDir), 'manifest.json');
+}
+
+function readManifest(manifestPath) {
+  if (!fs.existsSync(manifestPath)) {
+    return { package: PACKAGE_NAME, skills: [] };
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    if (!Array.isArray(data.skills)) data.skills = [];
+    return data;
+  } catch (e) {
+    return { package: PACKAGE_NAME, skills: [] };
+  }
+}
+
+function writeManifest(manifestPath, data) {
+  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+  fs.writeFileSync(manifestPath, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function recordSkillInstall(manifestPath, packageVersion, skillId, dirPath) {
+  const data = readManifest(manifestPath);
+  data.package = PACKAGE_NAME;
+  data.version = packageVersion;
+  data.updatedAt = new Date().toISOString();
+  const idx = data.skills.findIndex(s => s.dirPath === dirPath);
+  const entry = { id: skillId, dirPath, installedAt: new Date().toISOString() };
+  if (idx !== -1) data.skills[idx] = entry;
+  else data.skills.push(entry);
+  writeManifest(manifestPath, data);
+}
+
+// Removes one skill entry, and - once no skills remain in it - deletes the
+// manifest file itself rather than leaving an empty bookkeeping file behind.
+function removeSkillFromManifest(manifestPath, dirPath) {
+  if (!fs.existsSync(manifestPath)) return;
+  const data = readManifest(manifestPath);
+  data.skills = data.skills.filter(s => s.dirPath !== dirPath);
+  if (data.skills.length === 0) {
+    fs.unlinkSync(manifestPath);
+  } else {
+    writeManifest(manifestPath, data);
+  }
+}
+
+module.exports = {
+  PACKAGE_NAME,
+  HARNESS_AUTHOR,
+  HARNESS_DIR_NAME,
+  getHarnessDir,
+  getManifestPath,
+  readManifest,
+  writeManifest,
+  recordSkillInstall,
+  removeSkillFromManifest,
+};

package/scripts/lib/prompts.js

@@ -0,0 +1,241 @@
+// Terminal TUI primitives used by the interactive installer flow. No install
+// or filesystem logic lives here - purely input/output.
+const readline = require('readline');
+
+function interactiveSelect(items, pageSize = items.length) {
+  return new Promise((resolve) => {
+    let cursor = 0;
+    let scrollIndex = 0;
+    let visibleItems = [];
+    const isScrollable = items.length > pageSize;
+
+    function render() {
+      readline.cursorTo(process.stdout, 0);
+
+      if (isScrollable) {
+        if (cursor >= scrollIndex + pageSize) {
+          scrollIndex = cursor - pageSize + 1;
+        } else if (cursor < scrollIndex) {
+          scrollIndex = cursor;
+        }
+      }
+
+      visibleItems = items.slice(scrollIndex, scrollIndex + pageSize);
+      const writeLines = [];
+
+      if (isScrollable) {
+        if (scrollIndex > 0) {
+          writeLines.push(`  ▲ (more above)`);
+        } else {
+          writeLines.push(``); // Spacer
+        }
+      }
+
+      for (let i = 0; i < visibleItems.length; i++) {
+        const itemIndex = scrollIndex + i;
+        const item = visibleItems[i];
+        const isSelected = item.checked ? '[x]' : '[ ]';
+        const isCurrent = itemIndex === cursor ? '> ' : '  ';
+        const desc = item.description ? ` - ${item.description}` : '';
+        const lineText = `${isCurrent}${isSelected} ${item.name || item.id}${desc}`;
+        const maxCols = process.stdout.columns || 80;
+        const truncated = lineText.length > maxCols - 5
+          ? lineText.slice(0, maxCols - 8) + '...'
+          : lineText;
+        writeLines.push(truncated);
+      }
+
+      if (isScrollable) {
+        if (scrollIndex + pageSize < items.length) {
+          writeLines.push(`  ▼ (more below)`);
+        } else {
+          writeLines.push(``); // Spacer
+        }
+      }
+
+      writeLines.push(``);
+      writeLines.push(`(Use Up/Down Arrow keys to navigate, Space to toggle, Enter to confirm)`);
+
+      for (const line of writeLines) {
+        readline.clearLine(process.stdout, 0);
+        process.stdout.write(`${line}\n`);
+      }
+    }
+
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+
+    // Hide cursor
+    process.stdout.write('[?25l');
+
+    render();
+
+    function cleanup() {
+      // Show cursor again
+      process.stdout.write('[?25h');
+      process.stdin.removeListener('keypress', handleKeypress);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+    }
+
+    function handleKeypress(str, key) {
+      if (key) {
+        if (key.ctrl && key.name === 'c') {
+          cleanup();
+          process.exit(130);
+        }
+
+        const linesToMove = pageSize + (isScrollable ? 4 : 2);
+
+        if (key.name === 'up') {
+          cursor = (cursor - 1 + items.length) % items.length;
+          readline.moveCursor(process.stdout, 0, -linesToMove);
+          render();
+        } else if (key.name === 'down') {
+          cursor = (cursor + 1) % items.length;
+          readline.moveCursor(process.stdout, 0, -linesToMove);
+          render();
+        } else if (key.name === 'space' || str === ' ') {
+          const itemIndex = cursor;
+          items[itemIndex].checked = !items[itemIndex].checked;
+          readline.moveCursor(process.stdout, 0, -linesToMove);
+          render();
+        } else if (key.name === 'return' || key.name === 'enter') {
+          cleanup();
+          readline.moveCursor(process.stdout, 0, -linesToMove);
+          for (let i = 0; i < linesToMove; i++) {
+            readline.clearLine(process.stdout, 0);
+            process.stdout.write('\n');
+          }
+          readline.moveCursor(process.stdout, 0, -linesToMove);
+
+          for (let i = 0; i < visibleItems.length; i++) {
+            readline.clearLine(process.stdout, 0);
+            const item = visibleItems[i];
+            const isSelected = item.checked ? '✔' : ' ';
+            process.stdout.write(`  ${isSelected} ${item.name || item.id}\n`);
+          }
+          if (isScrollable) {
+            readline.clearLine(process.stdout, 0);
+            process.stdout.write('\n');
+          }
+          readline.clearLine(process.stdout, 0);
+          process.stdout.write('\n');
+          resolve(items);
+        }
+      }
+    }
+
+    process.stdin.on('keypress', handleKeypress);
+  });
+}
+
+async function askQuestion(query) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise(resolve => {
+    rl.question(query, answer => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+function interactiveSingleSelect(items) {
+  return new Promise((resolve) => {
+    let cursor = 0;
+    if (!items.some(i => i.checked)) {
+      items[0].checked = true;
+    }
+
+    function render() {
+      readline.cursorTo(process.stdout, 0);
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const isSelected = item.checked ? '(o)' : '( )';
+        const isCurrent = i === cursor ? '> ' : '  ';
+        readline.clearLine(process.stdout, 0);
+        process.stdout.write(`${isCurrent}${isSelected} ${item.name}\n`);
+      }
+      readline.clearLine(process.stdout, 0);
+      process.stdout.write(`\n`);
+      readline.clearLine(process.stdout, 0);
+      process.stdout.write(`(Use Up/Down Arrow keys to navigate, Space to select, Enter to confirm)\n`);
+    }
+
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    process.stdout.write('[?25l');
+    render();
+
+    function cleanup() {
+      process.stdout.write('[?25h');
+      process.stdin.removeListener('keypress', handleKeypress);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+    }
+
+    function handleKeypress(str, key) {
+      if (key) {
+        if (key.ctrl && key.name === 'c') {
+          cleanup();
+          process.exit(130);
+        }
+
+        const linesToMove = items.length + 2;
+
+        if (key.name === 'up') {
+          cursor = (cursor - 1 + items.length) % items.length;
+          readline.moveCursor(process.stdout, 0, -linesToMove);
+          render();
+        } else if (key.name === 'down') {
+          cursor = (cursor + 1) % items.length;
+          readline.moveCursor(process.stdout, 0, -linesToMove);
+          render();
+        } else if (key.name === 'space' || str === ' ') {
+          items.forEach((item, idx) => {
+            item.checked = (idx === cursor);
+          });
+          readline.moveCursor(process.stdout, 0, -linesToMove);
+          render();
+        } else if (key.name === 'return' || key.name === 'enter') {
+          items.forEach((item, idx) => {
+            item.checked = (idx === cursor);
+          });
+          cleanup();
+          readline.moveCursor(process.stdout, 0, -linesToMove);
+          for (let i = 0; i < linesToMove; i++) {
+            readline.clearLine(process.stdout, 0);
+            process.stdout.write('\n');
+          }
+          readline.moveCursor(process.stdout, 0, -linesToMove);
+
+          for (let i = 0; i < items.length; i++) {
+            readline.clearLine(process.stdout, 0);
+            const item = items[i];
+            const isSelected = item.checked ? '✔' : ' ';
+            process.stdout.write(`  ${isSelected} ${item.name}\n`);
+          }
+          readline.clearLine(process.stdout, 0);
+          process.stdout.write('\n');
+          resolve(items.find(item => item.checked).id);
+        }
+      }
+    }
+    process.stdin.on('keypress', handleKeypress);
+  });
+}
+
+module.exports = { interactiveSelect, interactiveSingleSelect, askQuestion };