helloagents 3.0.3-beta.1 → 3.0.8-beta.1

package/scripts/cli-codex.mjs

@@ -1,37 +1,37 @@
 import { join, dirname } from 'node:path';
-import { existsSync, copyFileSync, readdirSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import {
   ensureDir, safeRead, safeWrite, removeIfExists,
   readJsonOrThrow, copyEntries,
   createLink, removeLink, injectMarkedContent, removeMarkedContent,
 } from './cli-utils.mjs';
+import { ensureTimestampedBackup, readCodexBackup, removeCodexBackup } from './cli-codex-backup.mjs';
+import {
+  CODEX_MANAGED_TOML_COMMENT,
+  CODEX_PLUGIN_CONFIG_HEADER,
+  isManagedCodexHooks,
+  installCodexManagedTopLevelConfig,
+  isManagedCodexBackupInstruction,
+  isManagedCodexModelInstruction,
+  isManagedCodexNotify,
+  removeCodexPluginConfig,
+  restoreCodexTopLevelConfig,
+  upsertCodexPluginConfig,
+} from './cli-codex-config.mjs';
 import {
-  upsertTopLevelTomlKey,
-  upsertTopLevelTomlBlock,
   readTopLevelTomlLine,
-  readTopLevelTomlBlock,
-  ensureTopLevelTomlLine,
-  ensureTopLevelTomlBlock,
   readTomlKeyInSection,
   removeTomlKeyInSection,
-  removeTopLevelTomlBlock,
   ensureTomlKeyInSection,
-  stripTomlSection,
   removeTopLevelTomlLines,
 } from './cli-toml.mjs';
 
 export const CODEX_MARKETPLACE_NAME = 'local-plugins';
 export const CODEX_PLUGIN_NAME = 'helloagents';
 export const CODEX_PLUGIN_KEY = `${CODEX_PLUGIN_NAME}@${CODEX_MARKETPLACE_NAME}`;
-export const CODEX_PLUGIN_CONFIG_HEADER = `[plugins."${CODEX_PLUGIN_KEY}"]`;
-export const CODEX_MANAGED_TOML_COMMENT = '# helloagents-managed';
+export { CODEX_MANAGED_TOML_COMMENT, CODEX_PLUGIN_CONFIG_HEADER };
 export const CODEX_RUNTIME_CARRIER = 'AGENTS.md';
-const CODEX_BACKUP_TIMESTAMP_RE = /^\d{8}-\d{6}$/;
 const CODEX_CONFIG_BASENAME = 'config.toml';
-const CODEX_DEVELOPER_INSTRUCTIONS_BACKUP_BASENAME = 'developer_instructions';
-export const CODEX_DEVELOPER_INSTRUCTIONS = `CRITICAL: These are HelloAGENTS global defaults for Codex. Use them as the baseline for main-agent behavior. Spawned sub-agents should focus on the delegated task unless they are explicitly required to follow main-agent-only workflow.
-If the current workspace contains a project-level AGENTS.md or other repo-specific instructions, treat those as the more specific and authoritative instructions. Use these global defaults only where they do not conflict. Standby/global behavior is determined by the active workspace instructions, not by this global default block.
-If work was already in progress and earlier context was compressed, first restore the active project state from the most relevant project state files or other project-local context artifacts, then continue from the actual interruption point without restarting the workflow or repeating completed steps.`;
 export const CODEX_RUNTIME_ENTRIES = [
   '.codex-plugin',
   'assets',
@@ -46,142 +46,6 @@ export const CODEX_RUNTIME_ENTRIES = [
   'templates',
 ];
 
-function formatBackupTimestamp(date = new Date()) {
-  const pad = (value, size = 2) => String(value).padStart(size, '0');
-  return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
-}
-
-function getTimestampedBackupPath(filePath, backupBaseName) {
-  return join(dirname(filePath), `${backupBaseName}_${formatBackupTimestamp()}.bak`);
-}
-
-function listTimestampedBackups(directory, backupBaseName) {
-  if (!existsSync(directory)) return [];
-  return readdirSync(directory)
-    .filter((name) => name.startsWith(`${backupBaseName}_`) && name.endsWith('.bak'))
-    .filter((name) => CODEX_BACKUP_TIMESTAMP_RE.test(name.slice(backupBaseName.length + 1, -4)))
-    .sort();
-}
-
-function getLatestTimestampedBackupPath(filePath, backupBaseName) {
-  const directory = dirname(filePath);
-  const backups = listTimestampedBackups(directory, backupBaseName);
-  const latest = backups.at(-1);
-  return latest ? join(directory, latest) : '';
-}
-
-function readLatestTimestampedBackup(filePath, backupBaseName) {
-  const backupPath = getLatestTimestampedBackupPath(filePath, backupBaseName);
-  return backupPath ? safeRead(backupPath) || '' : '';
-}
-
-function removeLatestTimestampedBackup(filePath, backupBaseName) {
-  const backupPath = getLatestTimestampedBackupPath(filePath, backupBaseName);
-  if (backupPath) removeIfExists(backupPath);
-}
-
-function ensureTimestampedBackup(filePath, backupBaseName) {
-  if (!existsSync(filePath)) return '';
-  const existingBackup = getLatestTimestampedBackupPath(filePath, backupBaseName);
-  if (existingBackup) return existingBackup;
-  const backupPath = getTimestampedBackupPath(filePath, backupBaseName);
-  copyFileSync(filePath, backupPath);
-  return backupPath;
-}
-
-function readCodexBackup(filePath, backupBaseName) {
-  const latest = readLatestTimestampedBackup(filePath, backupBaseName);
-  if (latest) return latest;
-  const legacyPath = `${filePath}.bak`;
-  return safeRead(legacyPath) || '';
-}
-
-function removeCodexBackup(filePath, backupBaseName) {
-  removeLatestTimestampedBackup(filePath, backupBaseName);
-  removeIfExists(`${filePath}.bak`);
-}
-
-function isManagedCodexStandbyInstructionPath(normalized = '') {
-  return /\/\.codex\/AGENTS\.md/i.test(normalized)
-    || /\/\.codex\/helloagents\/bootstrap-lite\.md/i.test(normalized);
-}
-
-function isManagedCodexGlobalInstructionPath(normalized = '') {
-  return /\/plugins\/helloagents\/AGENTS\.md/i.test(normalized)
-    || /\/plugins\/helloagents\/bootstrap\.md/i.test(normalized);
-}
-
-function upsertCodexPluginConfig(text) {
-  const stripped = stripTomlSection(text, CODEX_PLUGIN_CONFIG_HEADER).text.trimEnd();
-  const block = `${CODEX_PLUGIN_CONFIG_HEADER}\nenabled = true`;
-  return stripped ? `${stripped}\n\n${block}\n` : `${block}\n`;
-}
-
-function removeCodexPluginConfig(text) {
-  return stripTomlSection(text, CODEX_PLUGIN_CONFIG_HEADER).text;
-}
-
-function isManagedCodexModelInstruction(line = '') {
-  const normalized = String(line || '').replace(/\\/g, '/');
-  return line.includes('model_instructions_file')
-    && (
-      line.includes(CODEX_MANAGED_TOML_COMMENT)
-      || isManagedCodexStandbyInstructionPath(normalized)
-      || isManagedCodexGlobalInstructionPath(normalized)
-    );
-}
-
-function isManagedCodexNotify(line = '') {
-  return line.includes('codex-notify') || (line.includes('helloagents') && line.includes('notify'));
-}
-
-function isManagedCodexBackupInstruction(line = '') {
-  return line.includes(CODEX_MANAGED_TOML_COMMENT);
-}
-
-function formatManagedCodexDeveloperInstructions() {
-  return `"""\n${CODEX_DEVELOPER_INSTRUCTIONS}\n"""`;
-}
-
-function backupUserCodexDeveloperInstructions(configPath, existingBlock) {
-  if (!existingBlock || existingBlock.includes('HelloAGENTS')) return;
-  const backupPath = getTimestampedBackupPath(configPath, CODEX_DEVELOPER_INSTRUCTIONS_BACKUP_BASENAME);
-  safeWrite(backupPath, `${existingBlock}\n`);
-}
-
-function sanitizeCodexDeveloperInstructionsBackup(block = '') {
-  const normalized = String(block || '').trim();
-  if (!normalized.startsWith('developer_instructions =')) return '';
-  if (normalized.includes(CODEX_DEVELOPER_INSTRUCTIONS)) return '';
-  return normalized;
-}
-
-function readCodexDeveloperInstructionsBackup(configPath) {
-  return sanitizeCodexDeveloperInstructionsBackup(
-    readCodexBackup(configPath, CODEX_DEVELOPER_INSTRUCTIONS_BACKUP_BASENAME),
-  );
-}
-
-function removeCodexDeveloperInstructionsBackup(configPath) {
-  removeCodexBackup(configPath, CODEX_DEVELOPER_INSTRUCTIONS_BACKUP_BASENAME);
-}
-
-function installCodexDeveloperInstructions(configPath, toml) {
-  const existing = readTopLevelTomlBlock(toml, 'developer_instructions');
-  backupUserCodexDeveloperInstructions(configPath, existing);
-  return upsertTopLevelTomlBlock(toml, 'developer_instructions', formatManagedCodexDeveloperInstructions());
-}
-
-function uninstallCodexDeveloperInstructions(configPath, toml) {
-  const existing = readTopLevelTomlBlock(toml, 'developer_instructions');
-  if (!existing.includes('HelloAGENTS')) return toml;
-  let next = removeTopLevelTomlBlock(toml, 'developer_instructions');
-  const backupDeveloperInstructions = readCodexDeveloperInstructionsBackup(configPath);
-  next = ensureTopLevelTomlBlock(next, 'developer_instructions', backupDeveloperInstructions);
-  removeCodexDeveloperInstructionsBackup(configPath);
-  return next;
-}
-
 function getDefaultCodexMarketplace() {
   return {
     name: CODEX_MARKETPLACE_NAME,
@@ -242,15 +106,18 @@ function removeCodexMarketplaceEntry(marketplaceFile) {
   return true;
 }
 
-function normalizePath(path) {
-  return path.replace(/\\/g, '/');
-}
-
 function buildCodexRuntimeCarrier(bootstrapContent) {
   const normalized = String(bootstrapContent || '').trim();
   return normalized ? `${normalized}\n` : '';
 }
 
+function injectCodexRuntimeCarrier(filePath, bootstrapPath) {
+  const bootstrapContent = safeRead(bootstrapPath);
+  if (!bootstrapContent) return false;
+  injectMarkedContent(filePath, buildCodexRuntimeCarrier(bootstrapContent).trimEnd());
+  return true;
+}
+
 function writeCodexRuntimeCarrier(filePath, bootstrapPath) {
   const bootstrapContent = safeRead(bootstrapPath);
   if (!bootstrapContent) return false;
@@ -258,26 +125,73 @@ function writeCodexRuntimeCarrier(filePath, bootstrapPath) {
   return true;
 }
 
+function cleanupCodexManagedConfig(configPath, { removePluginConfig = false } = {}) {
+  const backupToml = readCodexBackup(configPath, CODEX_CONFIG_BASENAME);
+  let toml = safeRead(configPath) || '';
+
+  const currentModelInstructions = readTopLevelTomlLine(toml, 'model_instructions_file');
+  const currentNotify = readTopLevelTomlLine(toml, 'notify');
+  const currentCodexHooks = readTomlKeyInSection(toml, '[features]', 'codex_hooks');
+
+  const shouldRestoreModelInstructions = isManagedCodexModelInstruction(currentModelInstructions);
+  const shouldRestoreNotify = isManagedCodexNotify(currentNotify);
+  const shouldRestoreCodexHooks = isManagedCodexHooks(currentCodexHooks);
+
+  if (removePluginConfig) {
+    toml = removeCodexPluginConfig(toml);
+  }
+  if (shouldRestoreModelInstructions) {
+    toml = removeTopLevelTomlLines(toml, (line) =>
+      line.startsWith('model_instructions_file =') && isManagedCodexModelInstruction(line)).text;
+  }
+  if (shouldRestoreNotify) {
+    toml = removeTopLevelTomlLines(toml, (line) =>
+      line.startsWith('notify =') && isManagedCodexNotify(line)).text;
+  }
+  if (shouldRestoreCodexHooks) {
+    toml = removeTomlKeyInSection(toml, '[features]', 'codex_hooks');
+  }
+
+  const backupModelInstructions = readTopLevelTomlLine(backupToml, 'model_instructions_file');
+  const backupNotify = readTopLevelTomlLine(backupToml, 'notify');
+  const backupCodexHooks = readTomlKeyInSection(backupToml, '[features]', 'codex_hooks');
+
+  toml = restoreCodexTopLevelConfig(toml, {
+    modelInstructionsLine: shouldRestoreModelInstructions && !isManagedCodexBackupInstruction(backupModelInstructions)
+      ? backupModelInstructions
+      : '',
+    notifyLine: shouldRestoreNotify && !isManagedCodexNotify(backupNotify)
+      ? backupNotify
+      : '',
+  });
+  toml = ensureTomlKeyInSection(
+    toml,
+    '[features]',
+    'codex_hooks',
+    shouldRestoreCodexHooks && !isManagedCodexHooks(backupCodexHooks)
+      ? backupCodexHooks
+      : '',
+  );
+
+  return toml;
+}
+
 export function installCodexStandby(home, pkgRoot) {
   const codexDir = join(home, '.codex');
   if (!existsSync(codexDir)) return false;
   ensureDir(codexDir);
 
   const codexAgentsPath = join(codexDir, CODEX_RUNTIME_CARRIER);
-  const bootstrapContent = safeRead(join(pkgRoot, 'bootstrap-lite.md'));
-  if (bootstrapContent) {
-    injectMarkedContent(
-      codexAgentsPath,
-      buildCodexRuntimeCarrier(bootstrapContent).trimEnd(),
-    );
-  }
+  injectCodexRuntimeCarrier(codexAgentsPath, join(pkgRoot, 'bootstrap-lite.md'));
 
   const configPath = join(codexDir, 'config.toml');
   let toml = safeRead(configPath) || '';
   ensureTimestampedBackup(configPath, CODEX_CONFIG_BASENAME);
 
-  toml = upsertTopLevelTomlKey(toml, 'notify', `["node", "${normalizePath(join(pkgRoot, 'scripts', 'notify.mjs'))}", "codex-notify"]`);
-  toml = installCodexDeveloperInstructions(configPath, toml);
+  toml = installCodexManagedTopLevelConfig(toml, {
+    modelInstructionsPath: codexAgentsPath,
+    notifyScriptPath: join(pkgRoot, 'scripts', 'notify.mjs'),
+  });
   safeWrite(configPath, toml);
 
   createLink(pkgRoot, join(codexDir, 'helloagents'));
@@ -292,34 +206,10 @@ export function uninstallCodexStandby(home) {
     removeMarkedContent(join(codexDir, 'AGENTS.md'));
 
     const configPath = join(codexDir, 'config.toml');
-    const backupToml = readCodexBackup(configPath, CODEX_CONFIG_BASENAME);
-    let toml = safeRead(configPath) || '';
-    if (toml.includes('helloagents') || toml.includes('HelloAGENTS')) {
-      toml = removeTopLevelTomlLines(toml, (line) => {
-        if (!line) return false;
-        if (line.startsWith('model_instructions_file =') && isManagedCodexModelInstruction(line)) return true;
-        if (line.startsWith('notify =') && line.includes('codex-notify')) return true;
-        return false;
-      }).text;
-      toml = uninstallCodexDeveloperInstructions(configPath, toml);
-      toml = removeTomlKeyInSection(toml, '[features]', 'codex_hooks');
-      const backupModelInstructions = readTopLevelTomlLine(backupToml, 'model_instructions_file');
-      const backupNotify = readTopLevelTomlLine(backupToml, 'notify');
-      toml = ensureTopLevelTomlLine(
-        toml,
-        'model_instructions_file',
-        isManagedCodexBackupInstruction(backupModelInstructions) ? '' : backupModelInstructions,
-      );
-      toml = ensureTopLevelTomlLine(
-        toml,
-        'notify',
-        isManagedCodexNotify(backupNotify) ? '' : backupNotify,
-      );
-      toml = ensureTomlKeyInSection(toml, '[features]', 'codex_hooks', readTomlKeyInSection(backupToml, '[features]', 'codex_hooks'));
-      if (toml.trim()) safeWrite(configPath, toml);
-      else removeIfExists(configPath);
-      changed = true;
-    }
+    const toml = cleanupCodexManagedConfig(configPath);
+    if (toml.trim()) safeWrite(configPath, toml);
+    else removeIfExists(configPath);
+    changed = true;
     removeCodexBackup(configPath, CODEX_CONFIG_BASENAME);
     removeIfExists(join(codexDir, 'hooks.json'));
     removeLink(join(codexDir, 'helloagents'));
@@ -366,19 +256,19 @@ export function installCodexGlobal(home, pkgRoot) {
     join(installedPluginRoot, CODEX_RUNTIME_CARRIER),
     join(installedPluginRoot, 'bootstrap.md'),
   );
+  const homeCarrierPath = join(codexDir, CODEX_RUNTIME_CARRIER);
+  injectCodexRuntimeCarrier(homeCarrierPath, join(pkgRoot, 'bootstrap.md'));
 
   ensureDir(join(home, '.agents', 'plugins'));
   updateCodexMarketplace(marketplaceFile);
 
   let toml = safeRead(configPath) || '';
   ensureTimestampedBackup(configPath, CODEX_CONFIG_BASENAME);
-  toml = upsertTopLevelTomlKey(
-    toml,
-    'notify',
-    `["node", "${normalizePath(join(pluginRoot, 'scripts', 'notify.mjs'))}", "codex-notify"]`,
-  );
+  toml = installCodexManagedTopLevelConfig(toml, {
+    modelInstructionsPath: homeCarrierPath,
+    notifyScriptPath: join(pluginRoot, 'scripts', 'notify.mjs'),
+  });
   toml = upsertCodexPluginConfig(toml);
-  toml = installCodexDeveloperInstructions(configPath, toml);
   safeWrite(configPath, toml);
 
   return true;
@@ -395,31 +285,9 @@ export function uninstallCodexGlobal(home) {
   removeIfExists(pluginRoot);
   removeIfExists(pluginCacheRoot);
   removeCodexMarketplaceEntry(marketplaceFile);
+  removeMarkedContent(join(codexDir, 'AGENTS.md'));
 
-  const backupToml = readCodexBackup(configPath, CODEX_CONFIG_BASENAME);
-  let toml = safeRead(configPath) || '';
-  toml = removeCodexPluginConfig(toml);
-  toml = uninstallCodexDeveloperInstructions(configPath, toml);
-  toml = removeTomlKeyInSection(toml, '[features]', 'codex_hooks');
-  toml = removeTopLevelTomlLines(toml, (line) =>
-    line.startsWith('model_instructions_file =')
-    && isManagedCodexModelInstruction(line)).text;
-  toml = removeTopLevelTomlLines(toml, (line) =>
-    line.startsWith('notify =')
-    && line.includes('/plugins/helloagents/scripts/notify.mjs')).text;
-  const backupModelInstructions = readTopLevelTomlLine(backupToml, 'model_instructions_file');
-  const backupNotify = readTopLevelTomlLine(backupToml, 'notify');
-  toml = ensureTopLevelTomlLine(
-    toml,
-    'model_instructions_file',
-    isManagedCodexBackupInstruction(backupModelInstructions) ? '' : backupModelInstructions,
-  );
-  toml = ensureTopLevelTomlLine(
-    toml,
-    'notify',
-    isManagedCodexNotify(backupNotify) ? '' : backupNotify,
-  );
-  toml = ensureTomlKeyInSection(toml, '[features]', 'codex_hooks', readTomlKeyInSection(backupToml, '[features]', 'codex_hooks'));
+  const toml = cleanupCodexManagedConfig(configPath, { removePluginConfig: true });
   if (toml.trim()) safeWrite(configPath, toml);
   else removeIfExists(configPath);
   removeCodexBackup(configPath, CODEX_CONFIG_BASENAME);

package/scripts/cli-config.mjs

@@ -7,6 +7,7 @@ export const DEFAULTS = {
   ralph_loop_enabled: true,
   guard_enabled: true,
   kb_create_mode: 1,
+  project_store_mode: 'local',
   commit_attribution: '',
   install_mode: 'standby',
 };

package/scripts/cli-doctor-render.mjs

@@ -0,0 +1,28 @@
+export function printDoctorText(runtime, report) {
+  console.log(`\nHelloAGENTS doctor\n`)
+  console.log(runtime.msg(
+    `配置:\n  package_version: ${report.config.packageVersion}\n  install_mode: ${report.config.installMode}\n  tracked_host_modes: ${JSON.stringify(report.config.trackedHostModes)}`,
+    `Config:\n  package_version: ${report.config.packageVersion}\n  install_mode: ${report.config.installMode}\n  tracked_host_modes: ${JSON.stringify(report.config.trackedHostModes)}`,
+  ))
+
+  for (const entry of report.hosts) {
+    console.log(`\n${entry.label}:`)
+    console.log(`  status: ${entry.status}`)
+    console.log(`  detected_mode: ${entry.detectedMode}`)
+    console.log(`  tracked_mode: ${entry.trackedMode}`)
+    for (const [key, value] of Object.entries(entry.checks)) {
+      console.log(`  ${key}: ${value ? 'ok' : 'missing'}`)
+    }
+    for (const note of entry.notes) {
+      console.log(`  note: ${note}`)
+    }
+    for (const issue of entry.issues) {
+      console.log(`  issue[${issue.code}]: ${issue.message}`)
+    }
+    if (entry.suggestedFix) {
+      console.log(`  suggested_fix: ${entry.suggestedFix}`)
+    }
+  }
+
+  console.log(`\nSummary: ok=${report.summary.ok} drift=${report.summary.drift} manual-plugin=${report.summary['manual-plugin']} not-installed=${report.summary['not-installed']} issues=${report.summary.issueCount}\n`)
+}