drt-method 1.0.0

package/src/scripts/memlog.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+
+const MEMLOG = '.memlog.md';
+
+function now() {
+  const d = new Date();
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+function resolvePath(args) {
+  if (args.path) {
+    return path.resolve(args.path);
+  }
+  return path.join(path.resolve(args.workspace), MEMLOG);
+}
+
+function split(text) {
+  const lines = text.split(/\r?\n/);
+  if (!lines.length || lines[0] !== '---') {
+    throw new Error('.memlog.md has no frontmatter');
+  }
+  const end = lines.findIndex((line, i) => i > 0 && line === '---');
+  if (end === -1) {
+    throw new Error('.memlog.md frontmatter is not terminated');
+  }
+  const meta = {};
+  for (const line of lines.slice(1, end)) {
+    const idx = line.indexOf(':');
+    if (idx !== -1) {
+      meta[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+    }
+  }
+  const body = lines.slice(end + 1).join('\n').replace(/^\n/, '');
+  return { meta, body };
+}
+
+function render(meta, body) {
+  const fm = Object.entries(meta)
+    .map(([k, v]) => `${k}: ${String(v).split(/\r?\n/).join(' ')}`)
+    .join('\n');
+  return `---\n${fm}\n---\n\n${body.replace(/\n$/, '')}\n`;
+}
+
+function touch(meta) {
+  delete meta.updated;
+  meta.updated = now();
+}
+
+function writeAtomic(filePath, text) {
+  const tmp = `${filePath}.tmp`;
+  fs.writeFileSync(tmp, text, 'utf8');
+  try {
+    const fd = fs.openSync(tmp, 'r');
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+  } catch {
+  }
+  fs.renameSync(tmp, filePath);
+}
+
+function entryCount(body) {
+  return body.split(/\r?\n/).filter((line) => line.startsWith('- ')).length;
+}
+
+function ack(filePath, body) {
+  process.stdout.write(`${JSON.stringify({ ok: true, memlog: filePath, entries: entryCount(body) })}\n`);
+}
+
+function cmdInit(args) {
+  const filePath = resolvePath(args);
+  if (fs.existsSync(filePath)) {
+    process.stderr.write(`error: ${filePath} already exists; use append/set to update it\n`);
+    process.exit(2);
+  }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const meta = {};
+  for (const pair of args.field || []) {
+    const idx = pair.indexOf('=');
+    if (idx === -1) {
+      process.stderr.write(`error: --field expects key=value, got ${JSON.stringify(pair)}\n`);
+      process.exit(2);
+    }
+    meta[pair.slice(0, idx).trim()] = pair.slice(idx + 1).trim();
+  }
+  touch(meta);
+  writeAtomic(filePath, render(meta, ''));
+  ack(filePath, '');
+}
+
+function cmdAppend(args) {
+  const filePath = resolvePath(args);
+  const { meta, body } = split(fs.readFileSync(filePath, 'utf8'));
+  const text = args.text.replace(/\s+/g, ' ').trim();
+  let label = args.type || '';
+  if (args.by) {
+    label = `${label} by ${args.by}`.trim();
+  }
+  const tag = label ? `(${label}) ` : '';
+  const entry = `- ${tag}${text}`;
+  const newBody = body.trim() ? `${body.replace(/\n$/, '')}\n${entry}` : entry;
+  touch(meta);
+  writeAtomic(filePath, render(meta, newBody));
+  ack(filePath, newBody);
+}
+
+function cmdSet(args) {
+  const filePath = resolvePath(args);
+  const { meta, body } = split(fs.readFileSync(filePath, 'utf8'));
+  meta[args.key] = args.value;
+  touch(meta);
+  writeAtomic(filePath, render(meta, body));
+  ack(filePath, body);
+}
+
+function parseArgs(argv) {
+  const result = { cmd: null, field: [], path: null, workspace: null, text: null, type: null, by: null, key: null, value: null };
+  const positional = [];
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === 'init' || arg === 'append' || arg === 'set') {
+      result.cmd = arg;
+    } else if (arg === '--workspace') {
+      result.workspace = argv[++i];
+    } else if (arg === '--path') {
+      result.path = argv[++i];
+    } else if (arg === '--field') {
+      result.field.push(argv[++i]);
+    } else if (arg === '--text') {
+      result.text = argv[++i];
+    } else if (arg === '--type') {
+      result.type = argv[++i];
+    } else if (arg === '--by') {
+      result.by = argv[++i];
+    } else if (arg === '--key') {
+      result.key = argv[++i];
+    } else if (arg === '--value') {
+      result.value = argv[++i];
+    } else if (arg === '--help' || arg === '-h') {
+      process.stdout.write('Usage: node memlog.js <init|append|set> --workspace <dir> | --path <file> [options]\n');
+      process.exit(0);
+    } else {
+      positional.push(arg);
+    }
+  }
+  if (!result.cmd && positional.length) {
+    result.cmd = positional[0];
+  }
+  if (!result.cmd) {
+    process.stderr.write('error: command required: init, append, or set\n');
+    process.exit(1);
+  }
+  if (!result.path && !result.workspace) {
+    process.stderr.write('error: --workspace or --path is required\n');
+    process.exit(1);
+  }
+  return result;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  if (args.cmd === 'init') {
+    cmdInit(args);
+  } else if (args.cmd === 'append') {
+    if (!args.text) {
+      process.stderr.write('error: --text is required for append\n');
+      process.exit(1);
+    }
+    cmdAppend(args);
+  } else if (args.cmd === 'set') {
+    if (!args.key || args.value == null) {
+      process.stderr.write('error: --key and --value are required for set\n');
+      process.exit(1);
+    }
+    cmdSet(args);
+  } else {
+    process.stderr.write(`error: unknown command ${args.cmd}\n`);
+    process.exit(1);
+  }
+}
+
+main();

package/src/scripts/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "drt-runtime-scripts",
+  "private": true,
+  "dependencies": {
+    "@iarna/toml": "^2.2.5"
+  }
+}

package/src/scripts/resolve-config.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+const path = require('path');
+const { loadToml } = require('./lib/load-toml');
+const { deepMerge, extractKey } = require('./lib/merge-utils');
+
+function parseArgs(argv) {
+  const args = { projectRoot: null, keys: [] };
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--project-root' || arg === '-p') {
+      args.projectRoot = argv[++i];
+    } else if (arg === '--key' || arg === '-k') {
+      args.keys.push(argv[++i]);
+    } else if (arg === '--help' || arg === '-h') {
+      process.stdout.write(`Usage: node resolve-config.js --project-root <path> [--key <dotted.path> ...]\n`);
+      process.exit(0);
+    }
+  }
+  if (!args.projectRoot) {
+    process.stderr.write('error: --project-root is required\n');
+    process.exit(1);
+  }
+  return args;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  const projectRoot = path.resolve(args.projectRoot);
+  const drtDir = path.join(projectRoot, '_drt');
+
+  const baseTeam = loadToml(path.join(drtDir, 'config.toml'), { required: true });
+  const baseUser = loadToml(path.join(drtDir, 'config.user.toml'));
+  const customTeam = loadToml(path.join(drtDir, 'custom', 'config.toml'));
+  const customUser = loadToml(path.join(drtDir, 'custom', 'config.user.toml'));
+
+  let merged = deepMerge(baseTeam, baseUser);
+  merged = deepMerge(merged, customTeam);
+  merged = deepMerge(merged, customUser);
+
+  let output;
+  if (args.keys.length > 0) {
+    output = {};
+    for (const key of args.keys) {
+      const value = extractKey(merged, key);
+      if (value !== undefined) {
+        output[key] = value;
+      }
+    }
+  } else {
+    output = merged;
+  }
+
+  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+}
+
+main();

package/src/scripts/resolve-customization.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const { loadToml } = require('./lib/load-toml');
+const { deepMerge, extractKey } = require('./lib/merge-utils');
+
+function findProjectRoot(start) {
+  let current = path.resolve(start);
+  while (true) {
+    if (fs.existsSync(path.join(current, '_drt')) || fs.existsSync(path.join(current, '.git'))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+function parseArgs(argv) {
+  const args = { skill: null, keys: [] };
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--skill' || arg === '-s') {
+      args.skill = argv[++i];
+    } else if (arg === '--key' || arg === '-k') {
+      args.keys.push(argv[++i]);
+    } else if (arg === '--help' || arg === '-h') {
+      process.stdout.write(`Usage: node resolve-customization.js --skill <skill-dir> [--key <dotted.path> ...]\n`);
+      process.exit(0);
+    }
+  }
+  if (!args.skill) {
+    process.stderr.write('error: --skill is required\n');
+    process.exit(1);
+  }
+  return args;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  const skillDir = path.resolve(args.skill);
+  const skillName = path.basename(skillDir);
+  const defaultsPath = path.join(skillDir, 'customize.toml');
+
+  const defaults = loadToml(defaultsPath, { required: true });
+  const projectRoot = findProjectRoot(skillDir) || findProjectRoot(process.cwd());
+
+  let team = {};
+  let user = {};
+  if (projectRoot) {
+    const customDir = path.join(projectRoot, '_drt', 'custom');
+    team = loadToml(path.join(customDir, `${skillName}.toml`));
+    user = loadToml(path.join(customDir, `${skillName}.user.toml`));
+  }
+
+  let merged = deepMerge(defaults, team);
+  merged = deepMerge(merged, user);
+
+  let output;
+  if (args.keys.length > 0) {
+    output = {};
+    for (const key of args.keys) {
+      const value = extractKey(merged, key);
+      if (value !== undefined) {
+        output[key] = value;
+      }
+    }
+  } else {
+    output = merged;
+  }
+
+  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+}
+
+main();

package/tools/installer/cli-utils.js

@@ -0,0 +1,53 @@
+const prompts = require('./prompts');
+
+const CLIUtils = {
+  /**
+   * Display DRT Method logo and version using @clack intro + box
+   */
+  async displayLogo() {
+    const color = await prompts.getColor();
+    const termWidth = process.stdout.columns || 80;
+
+    // Full "DRT Method" logo for wide terminals, "DRT" only for narrow
+    const logoWide = [
+      ' ██████╗ ███╗   ███╗ █████╗ ██████╗     ███╗   ███╗███████╗████████╗██╗  ██╗ ██████╗ ██████╗ ™',
+      '██╔══██╗████╗ ████║██╔══██╗██╔══██╗    ████╗ ████║██╔════╝╚══██╔══╝██║  ██║██╔═══██╗██╔══██╗',
+      '██████╔╝██╔████╔██║███████║██║  ██║    ██╔████╔██║█████╗     ██║   ███████║██║   ██║██║  ██║',
+      '██╔══██╗██║╚██╔╝██║██╔══██║██║  ██║    ██║╚██╔╝██║██╔══╝     ██║   ██╔══██║██║   ██║██║  ██║',
+      '██████╔╝██║ ╚═╝ ██║██║  ██║██████╔╝    ██║ ╚═╝ ██║███████╗   ██║   ██║  ██║╚██████╔╝██████╔╝',
+      '╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝╚═════╝     ╚═╝     ╚═╝╚══════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ',
+    ];
+
+    const logoNarrow = [
+      '    ██████╗ ███╗   ███╗ █████╗ ██████╗ ™',
+      '    ██╔══██╗████╗ ████║██╔══██╗██╔══██╗',
+      '    ██████╔╝██╔████╔██║███████║██║  ██║',
+      '    ██╔══██╗██║╚██╔╝██║██╔══██║██║  ██║',
+      '    ██████╔╝██║ ╚═╝ ██║██║  ██║██████╔╝',
+      '    ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝╚═════╝',
+    ];
+
+    const logoLines = termWidth >= 95 ? logoWide : logoNarrow;
+    const logo = logoLines.map((line) => color.blue(line)).join('\n');
+    const tagline = color.white('    Build More, Architect Dreams\n    © DRT Code');
+
+    await prompts.box(`${logo}\n${tagline}`, '', {
+      contentAlign: 'center',
+      rounded: true,
+      formatBorder: color.blue,
+    });
+  },
+
+  /**
+   * Display module configuration header
+   * @param {string} moduleName - Module name (fallback if no custom header)
+   * @param {string} header - Custom header from module.yaml
+   * @param {string} subheader - Custom subheader from module.yaml
+   */
+  async displayModuleConfigHeader(moduleName, header = null, subheader = null) {
+    const title = header || `Configuring ${moduleName.toUpperCase()} Module`;
+    await prompts.note(subheader || '', title);
+  },
+};
+
+module.exports = { CLIUtils };

package/tools/installer/commands/install.js

@@ -0,0 +1,149 @@
+const path = require('node:path');
+const prompts = require('../prompts');
+const { Installer } = require('../core/installer');
+const { UI } = require('../ui');
+
+const installer = new Installer();
+const ui = new UI();
+
+module.exports = {
+  command: 'install',
+  description: 'Install DRT Method agents and tools',
+  options: [
+    ['-d, --debug', 'Enable debug output for manifest generation'],
+    ['--directory <path>', 'Installation directory (default: current directory)'],
+    ['--modules <modules>', 'Comma-separated list of module IDs to install (e.g., "bmm,bmb")'],
+    [
+      '--tools <tools>',
+      'Comma-separated list of tool/IDE IDs to configure (e.g., "claude-code,cursor"). Required for fresh non-interactive (--yes) installs. Run with --list-tools to see all valid IDs.',
+    ],
+    ['--list-tools', 'Print all supported tool/IDE IDs (with target directories) and exit.'],
+    [
+      '--set <spec>',
+      'Set a module config option non-interactively. Spec format: <module>.<key>=<value> (e.g. bmm.project_knowledge=research). Repeatable. Run --list-options to see available keys.',
+      (value, prev) => [...(prev || []), value],
+      [],
+    ],
+    [
+      '--list-options [module]',
+      'List available --set keys for all locally-known official modules, or for a single module by code, then exit.',
+    ],
+    ['--action <type>', 'Action type for existing installations: install, update, or quick-update'],
+    ['--user-name <name>', 'Name for agents to use (default: system username)'],
+    ['--communication-language <lang>', 'Language for agent communication (default: English)'],
+    ['--document-output-language <lang>', 'Language for document output (default: English)'],
+    ['--output-folder <path>', 'Output folder path relative to project root (default: _drt-output)'],
+    ['--custom-source <sources>', 'Comma-separated Git URLs or local paths to install custom modules from'],
+    ['-y, --yes', 'Accept all defaults and skip prompts where possible'],
+    [
+      '--channel <channel>',
+      'Apply channel (stable|next) to all external modules being installed. --all-stable and --all-next are aliases.',
+    ],
+    ['--all-stable', 'Alias for --channel=stable. Resolves externals to the highest stable release tag.'],
+    ['--all-next', 'Alias for --channel=next. Resolves externals to main HEAD.'],
+    ['--next <code>', 'Install module <code> from main HEAD (next channel). Repeatable.', (value, prev) => [...(prev || []), value], []],
+    [
+      '--pin <spec>',
+      'Pin module to a specific tag: --pin CODE=TAG (e.g. --pin bmb=v1.7.0). Repeatable.',
+      (value, prev) => [...(prev || []), value],
+      [],
+    ],
+  ],
+  action: async (options) => {
+    try {
+      if (options.listTools) {
+        const { formatPlatformList } = require('../ide/platform-codes');
+        process.stdout.write((await formatPlatformList()) + '\n');
+        process.exit(0);
+      }
+
+      if (options.listOptions !== undefined) {
+        const { formatOptionsList } = require('../list-options');
+        const moduleArg = options.listOptions === true ? null : options.listOptions;
+        const { text, ok } = await formatOptionsList(moduleArg);
+        const stream = ok ? process.stdout : process.stderr;
+        // process.exit() forces immediate termination and can truncate the
+        // buffered write when stdout/stderr is piped or captured by CI. Wait
+        // for the write to flush, then set process.exitCode and return so the
+        // event loop drains naturally. Non-zero exit when a single-module
+        // lookup misses so a CI typo like `--list-options bmn` doesn't look
+        // successful in scripts.
+        await new Promise((resolve, reject) => {
+          stream.write(text + '\n', (error) => (error ? reject(error) : resolve()));
+        });
+        process.exitCode = ok ? 0 : 1;
+        return;
+      }
+
+      const { checkWindowsNodeFromWsl } = require('../core/wsl-node-check');
+      await checkWindowsNodeFromWsl();
+
+      // Set debug flag as environment variable for all components
+      if (options.debug) {
+        process.env.DRT_DEBUG_MANIFEST = 'true';
+        await prompts.log.info('Debug mode enabled');
+      }
+
+      // Validate --set syntax up-front so malformed entries fail fast,
+      // before we touch the network or filesystem. Parsed entries are
+      // re-derived inside ui.js where overrides are seeded.
+      if (options.set && options.set.length > 0) {
+        const { parseSetEntries } = require('../set-overrides');
+        try {
+          parseSetEntries(options.set);
+        } catch (error) {
+          await prompts.log.error(error.message);
+          process.exit(1);
+        }
+      }
+
+      const config = await ui.promptInstall(options);
+
+      // Handle cancel
+      if (config.actionType === 'cancel') {
+        await prompts.log.warn('Installation cancelled.');
+        process.exit(0);
+      }
+
+      // Handle quick update separately. --set is a post-install TOML patch so
+      // it works the same way for quick-update as for a regular install — the
+      // installer runs, then `applySetOverrides` patches the central config
+      // files. Pass the parsed overrides through.
+      if (config.actionType === 'quick-update') {
+        const { parseSetEntries } = require('../set-overrides');
+        config.setOverrides = parseSetEntries(options.set || []);
+        const result = await installer.quickUpdate(config);
+        await prompts.log.success('Quick update complete!');
+        await prompts.log.info(`Updated ${result.moduleCount} modules with preserved settings (${result.modules.join(', ')})`);
+        process.exit(0);
+      }
+
+      // Regular install/update flow
+      const result = await installer.install(config);
+
+      // Check if installation was cancelled
+      if (result && result.cancelled) {
+        process.exit(0);
+      }
+
+      // Check if installation succeeded
+      if (result && result.success) {
+        process.exit(0);
+      }
+    } catch (error) {
+      try {
+        if (error.fullMessage) {
+          await prompts.log.error(error.fullMessage);
+        } else {
+          await prompts.log.error(`Installation failed: ${error.message}`);
+        }
+        if (error.stack && !error.expected) {
+          await prompts.log.message(error.stack);
+        }
+      } catch {
+        console.error(error.fullMessage || error.message || error);
+      }
+      process.exit(1);
+    }
+  },
+};

package/tools/installer/commands/status.js

@@ -0,0 +1,65 @@
+const path = require('node:path');
+const prompts = require('../prompts');
+const { Installer } = require('../core/installer');
+const { Manifest } = require('../core/manifest');
+const { UI } = require('../ui');
+
+const installer = new Installer();
+const manifest = new Manifest();
+const ui = new UI();
+
+module.exports = {
+  command: 'status',
+  description: 'Display DRT installation status and module versions',
+  options: [],
+  action: async (options) => {
+    try {
+      // Find the drt directory
+      const projectDir = process.cwd();
+      const { drtDir } = await installer.findDrtDir(projectDir);
+
+      // Check if drt directory exists
+      const fs = require('../fs-native');
+      if (!(await fs.pathExists(drtDir))) {
+        await prompts.log.warn('No DRT installation found in the current directory.');
+        await prompts.log.message(`Expected location: ${drtDir}`);
+        await prompts.log.message('Run "npx drt-method install" to set up a new installation.');
+        process.exit(0);
+        return;
+      }
+
+      // Read manifest
+      const manifestData = await manifest._readRaw(drtDir);
+
+      if (!manifestData) {
+        await prompts.log.warn('No DRT installation manifest found.');
+        await prompts.log.message('Run "npx drt-method install" to set up a new installation.');
+        process.exit(0);
+        return;
+      }
+
+      // Get installation info
+      const installation = manifestData.installation || {};
+      const modules = manifestData.modules || [];
+
+      // Check for available updates (only for external modules)
+      const availableUpdates = await manifest.checkForUpdates(drtDir);
+
+      // Display status
+      await ui.displayStatus({
+        installation,
+        modules,
+        availableUpdates,
+        drtDir,
+      });
+
+      process.exit(0);
+    } catch (error) {
+      await prompts.log.error(`Status check failed: ${error.message}`);
+      if (process.env.DRT_DEBUG) {
+        await prompts.log.message(error.stack);
+      }
+      process.exit(1);
+    }
+  },
+};