drt-method 1.0.0

package/tools/installer/commands/uninstall.js

@@ -0,0 +1,167 @@
+const path = require('node:path');
+const fs = require('../fs-native');
+const prompts = require('../prompts');
+const { Installer } = require('../core/installer');
+
+const installer = new Installer();
+
+module.exports = {
+  command: 'uninstall',
+  description: 'Remove DRT installation from the current project',
+  options: [
+    ['-y, --yes', 'Remove all DRT components without prompting (preserves user artifacts)'],
+    ['--directory <path>', 'Project directory (default: current directory)'],
+  ],
+  action: async (options) => {
+    try {
+      let projectDir;
+
+      if (options.directory) {
+        // Explicit --directory flag takes precedence
+        projectDir = path.resolve(options.directory);
+      } else if (options.yes) {
+        // Non-interactive mode: use current directory
+        projectDir = process.cwd();
+      } else {
+        // Interactive: ask user which directory to uninstall from
+        // select() handles cancellation internally (exits process)
+        const dirChoice = await prompts.select({
+          message: 'Where do you want to uninstall DRT from?',
+          choices: [
+            { value: 'cwd', name: `Current directory (${process.cwd()})` },
+            { value: 'other', name: 'Another directory...' },
+          ],
+        });
+
+        if (dirChoice === 'other') {
+          // text() handles cancellation internally (exits process)
+          const customDir = await prompts.text({
+            message: 'Enter the project directory path:',
+            placeholder: process.cwd(),
+            validate: (value) => {
+              if (!value || value.trim().length === 0) return 'Directory path is required';
+            },
+          });
+
+          projectDir = path.resolve(customDir.trim());
+        } else {
+          projectDir = process.cwd();
+        }
+      }
+
+      if (!(await fs.pathExists(projectDir))) {
+        await prompts.log.error(`Directory does not exist: ${projectDir}`);
+        process.exit(1);
+      }
+
+      const { drtDir } = await installer.findDrtDir(projectDir);
+
+      if (!(await fs.pathExists(drtDir))) {
+        await prompts.log.warn('No DRT installation found.');
+        process.exit(0);
+      }
+
+      const existingInstall = await installer.getStatus(projectDir);
+      const version = existingInstall.installed ? existingInstall.version : 'unknown';
+      const modules = existingInstall.moduleIds.join(', ');
+      const ides = existingInstall.ides.join(', ');
+
+      const outputFolder = await installer.getOutputFolder(projectDir);
+
+      await prompts.intro('DRT Uninstall');
+      await prompts.note(`Version: ${version}\nModules: ${modules}\nIDE integrations: ${ides}`, 'Current Installation');
+
+      let removeModules = true;
+      let removeIdeConfigs = true;
+      let removeOutputFolder = false;
+
+      if (!options.yes) {
+        // multiselect() handles cancellation internally (exits process)
+        const selected = await prompts.multiselect({
+          message: 'Select components to remove:',
+          options: [
+            {
+              value: 'modules',
+              label: `DRT Modules & data (${installer.drtFolderName}/)`,
+              hint: 'Core installation, agents, workflows, config',
+            },
+            { value: 'ide', label: 'IDE integrations', hint: ides || 'No IDEs configured' },
+            { value: 'output', label: `User artifacts (${outputFolder}/)`, hint: 'WARNING: Contains your work products' },
+          ],
+          initialValues: ['modules', 'ide'],
+          required: true,
+        });
+
+        removeModules = selected.includes('modules');
+        removeIdeConfigs = selected.includes('ide');
+        removeOutputFolder = selected.includes('output');
+
+        const red = (s) => `\u001B[31m${s}\u001B[0m`;
+        await prompts.note(
+          red('💀 This action is IRREVERSIBLE! Removed files cannot be recovered!') +
+            '\n' +
+            red('💀 IDE configurations and modules will need to be reinstalled.') +
+            '\n' +
+            red('💀 User artifacts are preserved unless explicitly selected.'),
+          '!! DESTRUCTIVE ACTION !!',
+        );
+
+        const confirmed = await prompts.confirm({
+          message: 'Proceed with uninstall?',
+          default: false,
+        });
+
+        if (!confirmed) {
+          await prompts.outro('Uninstall cancelled.');
+          process.exit(0);
+        }
+      }
+
+      // Phase 1: IDE integrations
+      if (removeIdeConfigs) {
+        const s = await prompts.spinner();
+        s.start('Removing IDE integrations...');
+        await installer.uninstallIdeConfigs(projectDir, existingInstall, { silent: true });
+        s.stop(`Removed IDE integrations (${ides || 'none'})`);
+      }
+
+      // Phase 2: User artifacts
+      if (removeOutputFolder) {
+        const s = await prompts.spinner();
+        s.start(`Removing user artifacts (${outputFolder}/)...`);
+        await installer.uninstallOutputFolder(projectDir, outputFolder);
+        s.stop('User artifacts removed');
+      }
+
+      // Phase 3: DRT modules & data (last — other phases may need _drt/)
+      if (removeModules) {
+        const s = await prompts.spinner();
+        s.start(`Removing DRT modules & data (${installer.drtFolderName}/)...`);
+        await installer.uninstallModules(projectDir);
+        s.stop('Modules & data removed');
+      }
+
+      const summary = [];
+      if (removeIdeConfigs) summary.push('IDE integrations cleaned');
+      if (removeModules) summary.push('Modules & data removed');
+      if (removeOutputFolder) summary.push('User artifacts removed');
+      if (!removeOutputFolder) summary.push(`User artifacts preserved in ${outputFolder}/`);
+
+      await prompts.note(summary.join('\n'), 'Summary');
+      await prompts.outro('To reinstall, run: npx drt-method install');
+
+      process.exit(0);
+    } catch (error) {
+      try {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        await prompts.log.error(`Uninstall failed: ${errorMessage}`);
+        if (error instanceof Error && error.stack) {
+          await prompts.log.message(error.stack);
+        }
+      } catch {
+        console.error(error instanceof Error ? error.message : error);
+      }
+      process.exit(1);
+    }
+  },
+};

package/tools/installer/core/config.js

@@ -0,0 +1,73 @@
+/**
+ * Clean install configuration built from user input.
+ * User input comes from either UI answers or headless CLI flags.
+ */
+class Config {
+  constructor({
+    directory,
+    modules,
+    ides,
+    skipPrompts,
+    verbose,
+    actionType,
+    coreConfig,
+    moduleConfigs,
+    quickUpdate,
+    channelOptions,
+    setOverrides,
+  }) {
+    this.directory = directory;
+    this.modules = Object.freeze([...modules]);
+    this.ides = Object.freeze([...ides]);
+    this.skipPrompts = skipPrompts;
+    this.verbose = verbose;
+    this.actionType = actionType;
+    this.coreConfig = coreConfig;
+    this.moduleConfigs = moduleConfigs;
+    this._quickUpdate = quickUpdate;
+    // channelOptions carry a Map + Set; don't deep-freeze.
+    this.channelOptions = channelOptions || null;
+    // Parsed `--set <module>.<key>=<value>` overrides, applied as a TOML
+    // patch AFTER the install finishes. Shape: { moduleCode: { key: value } }.
+    // Intentionally NOT integrated with the prompt/template/schema flow; see
+    // `tools/installer/set-overrides.js` for the rationale and tradeoffs.
+    this.setOverrides = setOverrides || {};
+    Object.freeze(this);
+  }
+
+  /**
+   * Build a clean install config from raw user input.
+   * @param {Object} userInput - UI answers or CLI flags
+   * @returns {Config}
+   */
+  static build(userInput) {
+    const modules = [...(userInput.modules || [])];
+    if (userInput.installCore && !modules.includes('core')) {
+      modules.unshift('core');
+    }
+
+    return new Config({
+      directory: userInput.directory,
+      modules,
+      ides: userInput.skipIde ? [] : [...(userInput.ides || [])],
+      skipPrompts: userInput.skipPrompts || false,
+      verbose: userInput.verbose || false,
+      actionType: userInput.actionType,
+      coreConfig: userInput.coreConfig || {},
+      moduleConfigs: userInput.moduleConfigs || null,
+      quickUpdate: userInput._quickUpdate || false,
+      channelOptions: userInput.channelOptions || null,
+      setOverrides: userInput.setOverrides || {},
+    });
+  }
+
+  hasCoreConfig() {
+    return this.coreConfig && Object.keys(this.coreConfig).length > 0;
+  }
+
+  isQuickUpdate() {
+    return this._quickUpdate;
+  }
+}
+
+module.exports = { Config };

package/tools/installer/core/existing-install.js

@@ -0,0 +1,121 @@
+const path = require('node:path');
+const fs = require('../fs-native');
+const yaml = require('yaml');
+const { Manifest } = require('./manifest');
+
+/**
+ * Immutable snapshot of an existing DRT installation.
+ * Pure query object — no filesystem operations after construction.
+ */
+class ExistingInstall {
+  #version;
+
+  constructor({ installed, version, hasCore, modules, ides }) {
+    this.installed = installed;
+    this.#version = version;
+    this.hasCore = hasCore;
+    this.modules = Object.freeze(modules.map((m) => Object.freeze({ ...m })));
+    this.moduleIds = Object.freeze(this.modules.map((m) => m.id));
+    this.ides = Object.freeze([...ides]);
+    Object.freeze(this);
+  }
+
+  get version() {
+    if (!this.installed) {
+      throw new Error('version is not available when nothing is installed');
+    }
+    return this.#version;
+  }
+
+  static empty() {
+    return new ExistingInstall({
+      installed: false,
+      version: null,
+      hasCore: false,
+      modules: [],
+      ides: [],
+    });
+  }
+
+  /**
+   * Scan a drt directory and return an immutable snapshot of what's installed.
+   * @param {string} drtDir - Path to drt directory
+   * @returns {Promise<ExistingInstall>}
+   */
+  static async detect(drtDir) {
+    if (!(await fs.pathExists(drtDir))) {
+      return ExistingInstall.empty();
+    }
+
+    let version = null;
+    let hasCore = false;
+    const modules = [];
+    let ides = [];
+
+    const manifest = new Manifest();
+    const manifestData = await manifest.read(drtDir);
+    if (manifestData) {
+      version = manifestData.version;
+      if (manifestData.ides) {
+        ides = manifestData.ides.filter((ide) => ide && typeof ide === 'string');
+      }
+    }
+
+    const corePath = path.join(drtDir, 'core');
+    if (await fs.pathExists(corePath)) {
+      hasCore = true;
+
+      if (!version) {
+        const coreConfigPath = path.join(corePath, 'config.yaml');
+        if (await fs.pathExists(coreConfigPath)) {
+          try {
+            const configContent = await fs.readFile(coreConfigPath, 'utf8');
+            const config = yaml.parse(configContent);
+            if (config.version) {
+              version = config.version;
+            }
+          } catch {
+            // Ignore config read errors
+          }
+        }
+      }
+    }
+
+    if (manifestData && manifestData.modules && manifestData.modules.length > 0) {
+      for (const moduleId of manifestData.modules) {
+        const modulePath = path.join(drtDir, moduleId);
+        const moduleConfigPath = path.join(modulePath, 'config.yaml');
+
+        const moduleInfo = {
+          id: moduleId,
+          path: modulePath,
+          version: 'unknown',
+        };
+
+        if (await fs.pathExists(moduleConfigPath)) {
+          try {
+            const configContent = await fs.readFile(moduleConfigPath, 'utf8');
+            const config = yaml.parse(configContent);
+            moduleInfo.version = config.version || 'unknown';
+            moduleInfo.name = config.name || moduleId;
+            moduleInfo.description = config.description;
+          } catch {
+            // Ignore config read errors
+          }
+        }
+
+        modules.push(moduleInfo);
+      }
+    }
+
+    const installed = hasCore || modules.length > 0 || !!manifestData;
+
+    if (!installed) {
+      return ExistingInstall.empty();
+    }
+
+    return new ExistingInstall({ installed, version, hasCore, modules, ides });
+  }
+}
+
+module.exports = { ExistingInstall };

package/tools/installer/core/install-paths.js

@@ -0,0 +1,132 @@
+const path = require('node:path');
+const fs = require('../fs-native');
+const { getProjectRoot } = require('../project-root');
+const { DRT_FOLDER_NAME } = require('../ide/shared/path-utils');
+
+class InstallPaths {
+  static async create(config) {
+    const srcDir = getProjectRoot();
+    await assertReadableDir(srcDir, 'DRT source root');
+
+    const pkgPath = path.join(srcDir, 'package.json');
+    await assertReadableFile(pkgPath, 'package.json');
+    const version = require(pkgPath).version;
+
+    const projectRoot = path.resolve(config.directory);
+    await ensureWritableDir(projectRoot, 'project root');
+
+    const drtDir = path.join(projectRoot, DRT_FOLDER_NAME);
+    const isUpdate = await fs.pathExists(drtDir);
+
+    const configDir = path.join(drtDir, '_config');
+    const coreDir = path.join(drtDir, 'core');
+    const scriptsDir = path.join(drtDir, 'scripts');
+    const customDir = path.join(drtDir, 'custom');
+
+    for (const [dir, label] of [
+      [drtDir, 'drt directory'],
+      [configDir, 'config directory'],
+      [coreDir, 'core module directory'],
+      [scriptsDir, 'shared scripts directory'],
+      [customDir, 'customizations directory'],
+    ]) {
+      await ensureWritableDir(dir, label);
+    }
+
+    return new InstallPaths({
+      srcDir,
+      version,
+      projectRoot,
+      drtDir,
+      configDir,
+      coreDir,
+      scriptsDir,
+      customDir,
+      isUpdate,
+    });
+  }
+
+  constructor(props) {
+    Object.assign(this, props);
+    Object.freeze(this);
+  }
+
+  manifestFile() {
+    return path.join(this.configDir, 'manifest.yaml');
+  }
+  centralConfig() {
+    return path.join(this.drtDir, 'config.toml');
+  }
+  centralUserConfig() {
+    return path.join(this.drtDir, 'config.user.toml');
+  }
+  filesManifest() {
+    return path.join(this.configDir, 'files-manifest.csv');
+  }
+  helpCatalog() {
+    return path.join(this.configDir, 'drt-help.csv');
+  }
+  moduleDir(name) {
+    return path.join(this.drtDir, name);
+  }
+  moduleConfig(name) {
+    return path.join(this.drtDir, name, 'config.yaml');
+  }
+}
+
+async function assertReadableDir(dirPath, label) {
+  const stat = await fs.stat(dirPath).catch(() => null);
+  if (!stat) {
+    throw new Error(`${label} does not exist: ${dirPath}`);
+  }
+  if (!stat.isDirectory()) {
+    throw new Error(`${label} is not a directory: ${dirPath}`);
+  }
+  try {
+    await fs.access(dirPath, fs.constants.R_OK);
+  } catch {
+    throw new Error(`${label} is not readable: ${dirPath}`);
+  }
+}
+
+async function assertReadableFile(filePath, label) {
+  const stat = await fs.stat(filePath).catch(() => null);
+  if (!stat) {
+    throw new Error(`${label} does not exist: ${filePath}`);
+  }
+  if (!stat.isFile()) {
+    throw new Error(`${label} is not a file: ${filePath}`);
+  }
+  try {
+    await fs.access(filePath, fs.constants.R_OK);
+  } catch {
+    throw new Error(`${label} is not readable: ${filePath}`);
+  }
+}
+
+async function ensureWritableDir(dirPath, label) {
+  const stat = await fs.stat(dirPath).catch(() => null);
+  if (stat && !stat.isDirectory()) {
+    throw new Error(`${label} exists but is not a directory: ${dirPath}`);
+  }
+
+  try {
+    await fs.ensureDir(dirPath);
+  } catch (error) {
+    if (error.code === 'EACCES') {
+      throw new Error(`${label}: permission denied creating directory: ${dirPath}`);
+    }
+    if (error.code === 'ENOSPC') {
+      throw new Error(`${label}: no space left on device: ${dirPath}`);
+    }
+    throw new Error(`${label}: cannot create directory: ${dirPath} (${error.message})`);
+  }
+
+  try {
+    await fs.access(dirPath, fs.constants.R_OK | fs.constants.W_OK);
+  } catch {
+    throw new Error(`${label} is not writable: ${dirPath}`);
+  }
+}
+
+module.exports = { InstallPaths };