@haaaiawd/anws 1.2.5 → 2.0.1

package/lib/install-state.js

@@ -0,0 +1,195 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { detectInstalledTargets } = require('./adapters');
+
+const INSTALL_LOCK_RELATIVE_PATH = '.anws/install-lock.json';
+const INSTALL_LOCK_VERSION = 1;
+
+function getInstallLockPath(cwd) {
+  return path.join(cwd, INSTALL_LOCK_RELATIVE_PATH);
+}
+
+function ensureString(value, fieldName) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error(`Invalid install-lock: ${fieldName} must be a non-empty string`);
+  }
+  return value;
+}
+
+function ensureObject(value, fieldName) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`Invalid install-lock: ${fieldName} must be an object`);
+  }
+  return value;
+}
+
+function ensureArray(value, fieldName) {
+  if (!Array.isArray(value)) {
+    throw new Error(`Invalid install-lock: ${fieldName} must be an array`);
+  }
+  return value;
+}
+
+function normalizeTargetInstallation(target) {
+  const normalized = ensureObject(target, 'targets[]');
+  const targetId = ensureString(normalized.targetId, 'targets[].targetId');
+  const targetLabel = ensureString(normalized.targetLabel, 'targets[].targetLabel');
+  const installedVersion = ensureString(normalized.installedVersion, 'targets[].installedVersion');
+  const managedFiles = Array.from(new Set(ensureArray(normalized.managedFiles || [], 'targets[].managedFiles')));
+  const ownership = Array.from(new Set(ensureArray(normalized.ownership || [], 'targets[].ownership')));
+
+  return {
+    targetId,
+    targetLabel,
+    installedVersion,
+    managedFiles,
+    ownership,
+    lastSuccessfulUpdate: normalized.lastSuccessfulUpdate && typeof normalized.lastSuccessfulUpdate === 'object'
+      ? {
+          version: ensureString(normalized.lastSuccessfulUpdate.version, 'targets[].lastSuccessfulUpdate.version'),
+          updatedAt: ensureString(normalized.lastSuccessfulUpdate.updatedAt, 'targets[].lastSuccessfulUpdate.updatedAt')
+        }
+      : null
+  };
+}
+
+function dedupeTargets(targets) {
+  const map = new Map();
+  for (const target of targets.map(normalizeTargetInstallation)) {
+    map.set(target.targetId, target);
+  }
+  return Array.from(map.values()).sort((a, b) => a.targetId.localeCompare(b.targetId));
+}
+
+function normalizeInstallLock(input) {
+  const source = ensureObject(input, 'install-lock');
+  const schemaVersion = source.schemaVersion ?? source.lockVersion ?? INSTALL_LOCK_VERSION;
+  if (!Number.isInteger(schemaVersion) || schemaVersion < 1) {
+    throw new Error('Invalid install-lock: schemaVersion must be a positive integer');
+  }
+
+  const cliVersion = ensureString(source.cliVersion, 'cliVersion');
+  const generatedAt = ensureString(source.generatedAt, 'generatedAt');
+  const targets = dedupeTargets(ensureArray(source.targets || [], 'targets'));
+  const lastUpdateSummary = source.lastUpdateSummary == null
+    ? null
+    : {
+        successfulTargets: Array.from(new Set(ensureArray(source.lastUpdateSummary.successfulTargets || [], 'lastUpdateSummary.successfulTargets'))),
+        failedTargets: Array.from(new Set(ensureArray(source.lastUpdateSummary.failedTargets || [], 'lastUpdateSummary.failedTargets'))),
+        updatedAt: ensureString(source.lastUpdateSummary.updatedAt, 'lastUpdateSummary.updatedAt')
+      };
+
+  return {
+    schemaVersion,
+    cliVersion,
+    generatedAt,
+    targets,
+    lastUpdateSummary
+  };
+}
+
+function createInstallLock({ cliVersion, generatedAt, targets = [], lastUpdateSummary = null }) {
+  return normalizeInstallLock({
+    schemaVersion: INSTALL_LOCK_VERSION,
+    cliVersion,
+    generatedAt,
+    targets,
+    lastUpdateSummary
+  });
+}
+
+async function readInstallLock(cwd) {
+  const lockPath = getInstallLockPath(cwd);
+  let raw;
+  try {
+    raw = await fs.readFile(lockPath, 'utf8');
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return { exists: false, lockPath, lock: null, error: null };
+    }
+    throw error;
+  }
+
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      exists: true,
+      lockPath,
+      lock: normalizeInstallLock(parsed),
+      error: null
+    };
+  } catch (error) {
+    return {
+      exists: true,
+      lockPath,
+      lock: null,
+      error: new Error(`Failed to read install-lock: ${error.message}`)
+    };
+  }
+}
+
+async function writeInstallLock(cwd, lockInput) {
+  const lockPath = getInstallLockPath(cwd);
+  const normalized = normalizeInstallLock(lockInput);
+  await fs.mkdir(path.dirname(lockPath), { recursive: true });
+  await fs.writeFile(lockPath, `${JSON.stringify(normalized, null, 2)}\n`, 'utf8');
+  return { lockPath, lock: normalized };
+}
+
+function summarizeTargetState(targetPlan, installedVersion) {
+  return normalizeTargetInstallation({
+    targetId: targetPlan.targetId,
+    targetLabel: targetPlan.targetLabel,
+    installedVersion,
+    managedFiles: targetPlan.managedFiles,
+    ownership: targetPlan.ownership
+  });
+}
+
+function detectLockDrift(lock, scannedTargets) {
+  const lockTargetIds = new Set((lock?.targets || []).map((item) => item.targetId));
+  const scannedTargetIds = new Set(scannedTargets.map((item) => item.id));
+
+  const missingOnDisk = Array.from(lockTargetIds).filter((targetId) => !scannedTargetIds.has(targetId));
+  const untrackedOnDisk = Array.from(scannedTargetIds).filter((targetId) => !lockTargetIds.has(targetId));
+
+  return {
+    hasDrift: missingOnDisk.length > 0 || untrackedOnDisk.length > 0,
+    missingOnDisk,
+    untrackedOnDisk
+  };
+}
+
+async function detectInstallState(cwd) {
+  const lockResult = await readInstallLock(cwd);
+  const scannedTargets = await detectInstalledTargets(cwd);
+  const lockTargets = lockResult.lock?.targets || [];
+  const selectedTargets = lockTargets.length > 0
+    ? lockTargets.map((item) => item.targetId)
+    : scannedTargets.map((item) => item.id);
+
+  return {
+    lockResult,
+    scannedTargets,
+    selectedTargets,
+    drift: detectLockDrift(lockResult.lock, scannedTargets),
+    needsFallback: !lockResult.exists || !!lockResult.error
+  };
+}
+
+module.exports = {
+  INSTALL_LOCK_RELATIVE_PATH,
+  INSTALL_LOCK_VERSION,
+  createInstallLock,
+  detectInstallState,
+  detectLockDrift,
+  dedupeTargets,
+  getInstallLockPath,
+  normalizeInstallLock,
+  normalizeTargetInstallation,
+  readInstallLock,
+  summarizeTargetState,
+  writeInstallLock
+};

package/lib/manifest.js

@@ -1,62 +1,204 @@
 'use strict';
 
+const { getTarget } = require('./adapters');
+
 /**
  * MANAGED_FILES — anws 托管文件清单
  *
  * 此数组列出 anws 包负责管理的所有文件路径（相对于目标项目根目录）。
  */
-const MANAGED_FILES = [
-  'AGENTS.md',
-  '.agent/skills/build-inspector/SKILL.md',
-  '.agent/skills/complexity-guard/references/anti_patterns.md',
-  '.agent/skills/complexity-guard/SKILL.md',
-  '.agent/skills/concept-modeler/prompts/GLOSSARY_PROMPT.md',
-  '.agent/skills/concept-modeler/references/ENTITY_EXTRACTION_PROMPT.md',
-  '.agent/skills/concept-modeler/scripts/glossary_gen.py',
-  '.agent/skills/concept-modeler/SKILL.md',
-  '.agent/skills/design-reviewer/SKILL.md',
-  '.agent/skills/git-forensics/references/ANALYSIS_METHODOLOGY.md',
-  '.agent/skills/git-forensics/scripts/git_forensics.py',
-  '.agent/skills/git-forensics/scripts/git_hotspots.py',
-  '.agent/skills/git-forensics/SKILL.md',
-  '.agent/skills/report-template/references/REPORT_TEMPLATE.md',
-  '.agent/skills/report-template/SKILL.md',
-  '.agent/skills/runtime-inspector/SKILL.md',
-  '.agent/skills/spec-writer/references/prd_template.md',
-  '.agent/skills/spec-writer/SKILL.md',
-  '.agent/skills/system-architect/references/rfc_template.md',
-  '.agent/skills/system-architect/SKILL.md',
-  '.agent/skills/system-designer/references/system-design-detail-template.md',
-  '.agent/skills/system-designer/references/system-design-template.md',
-  '.agent/skills/system-designer/SKILL.md',
-  '.agent/skills/task-planner/references/TASK_TEMPLATE.md',
-  '.agent/skills/task-planner/SKILL.md',
-  '.agent/skills/task-reviewer/SKILL.md',
-  '.agent/skills/tech-evaluator/references/ADR_TEMPLATE.md',
-  '.agent/skills/tech-evaluator/SKILL.md',
-  '.agent/workflows/blueprint.md',
-  '.agent/workflows/challenge.md',
-  '.agent/workflows/change.md',
-  '.agent/workflows/craft.md',
-  '.agent/workflows/design-system.md',
-  '.agent/workflows/explore.md',
-  '.agent/workflows/forge.md',
-  '.agent/workflows/genesis.md',
-  '.agent/workflows/quickstart.md',
-  '.agent/workflows/scout.md'
+const RESOURCE_REGISTRY = [
+  { id: 'blueprint', type: 'workflow', source: '.agents/workflows/blueprint.md', fileName: 'blueprint.md' },
+  { id: 'challenge', type: 'workflow', source: '.agents/workflows/challenge.md', fileName: 'challenge.md' },
+  { id: 'change', type: 'workflow', source: '.agents/workflows/change.md', fileName: 'change.md' },
+  { id: 'craft', type: 'workflow', source: '.agents/workflows/craft.md', fileName: 'craft.md' },
+  { id: 'design-system', type: 'workflow', source: '.agents/workflows/design-system.md', fileName: 'design-system.md' },
+  { id: 'explore', type: 'workflow', source: '.agents/workflows/explore.md', fileName: 'explore.md' },
+  { id: 'forge', type: 'workflow', source: '.agents/workflows/forge.md', fileName: 'forge.md' },
+  { id: 'genesis', type: 'workflow', source: '.agents/workflows/genesis.md', fileName: 'genesis.md' },
+  { id: 'probe', type: 'workflow', source: '.agents/workflows/probe.md', fileName: 'probe.md' },
+  { id: 'quickstart', type: 'workflow', source: '.agents/workflows/quickstart.md', fileName: 'quickstart.md' },
+  { id: 'upgrade', type: 'workflow', source: '.agents/workflows/upgrade.md', fileName: 'upgrade.md' },
+  { id: 'concept-modeler', type: 'skill', source: '.agents/skills/concept-modeler/SKILL.md', fileName: 'concept-modeler/SKILL.md' },
+  { id: 'design-reviewer', type: 'skill', source: '.agents/skills/design-reviewer/SKILL.md', fileName: 'design-reviewer/SKILL.md' },
+  { id: 'nexus-mapper', type: 'skill', source: '.agents/skills/nexus-mapper/SKILL.md', fileName: 'nexus-mapper/SKILL.md' },
+  { id: 'nexus-mapper-language-customization', type: 'skill', source: '.agents/skills/nexus-mapper/references/language-customization.md', fileName: 'nexus-mapper/references/language-customization.md' },
+  { id: 'nexus-mapper-output-schema', type: 'skill', source: '.agents/skills/nexus-mapper/references/output-schema.md', fileName: 'nexus-mapper/references/output-schema.md' },
+  { id: 'nexus-mapper-probe-protocol', type: 'skill', source: '.agents/skills/nexus-mapper/references/probe-protocol.md', fileName: 'nexus-mapper/references/probe-protocol.md' },
+  { id: 'nexus-mapper-extract-ast', type: 'skill', source: '.agents/skills/nexus-mapper/scripts/extract_ast.py', fileName: 'nexus-mapper/scripts/extract_ast.py' },
+  { id: 'nexus-mapper-git-detective', type: 'skill', source: '.agents/skills/nexus-mapper/scripts/git_detective.py', fileName: 'nexus-mapper/scripts/git_detective.py' },
+  { id: 'nexus-mapper-languages', type: 'skill', source: '.agents/skills/nexus-mapper/scripts/languages.json', fileName: 'nexus-mapper/scripts/languages.json' },
+  { id: 'nexus-mapper-query-graph', type: 'skill', source: '.agents/skills/nexus-mapper/scripts/query_graph.py', fileName: 'nexus-mapper/scripts/query_graph.py' },
+  { id: 'nexus-mapper-requirements', type: 'skill', source: '.agents/skills/nexus-mapper/scripts/requirements.txt', fileName: 'nexus-mapper/scripts/requirements.txt' },
+  { id: 'report-template', type: 'skill', source: '.agents/skills/report-template/SKILL.md', fileName: 'report-template/SKILL.md' },
+  { id: 'report-template-reference', type: 'skill', source: '.agents/skills/report-template/references/REPORT_TEMPLATE.md', fileName: 'report-template/references/REPORT_TEMPLATE.md' },
+  { id: 'runtime-inspector', type: 'skill', source: '.agents/skills/runtime-inspector/SKILL.md', fileName: 'runtime-inspector/SKILL.md' },
+  { id: 'sequential-thinking', type: 'skill', source: '.agents/skills/sequential-thinking/SKILL.md', fileName: 'sequential-thinking/SKILL.md' },
+  { id: 'spec-writer', type: 'skill', source: '.agents/skills/spec-writer/SKILL.md', fileName: 'spec-writer/SKILL.md' },
+  { id: 'spec-writer-prd-template', type: 'skill', source: '.agents/skills/spec-writer/references/prd_template.md', fileName: 'spec-writer/references/prd_template.md' },
+  { id: 'system-architect', type: 'skill', source: '.agents/skills/system-architect/SKILL.md', fileName: 'system-architect/SKILL.md' },
+  { id: 'system-architect-rfc-template', type: 'skill', source: '.agents/skills/system-architect/references/rfc_template.md', fileName: 'system-architect/references/rfc_template.md' },
+  { id: 'system-designer', type: 'skill', source: '.agents/skills/system-designer/SKILL.md', fileName: 'system-designer/SKILL.md' },
+  { id: 'system-designer-detail-template', type: 'skill', source: '.agents/skills/system-designer/references/system-design-detail-template.md', fileName: 'system-designer/references/system-design-detail-template.md' },
+  { id: 'system-designer-template', type: 'skill', source: '.agents/skills/system-designer/references/system-design-template.md', fileName: 'system-designer/references/system-design-template.md' },
+  { id: 'task-planner', type: 'skill', source: '.agents/skills/task-planner/SKILL.md', fileName: 'task-planner/SKILL.md' },
+  { id: 'task-planner-template', type: 'skill', source: '.agents/skills/task-planner/references/TASK_TEMPLATE.md', fileName: 'task-planner/references/TASK_TEMPLATE.md' },
+  { id: 'task-reviewer', type: 'skill', source: '.agents/skills/task-reviewer/SKILL.md', fileName: 'task-reviewer/SKILL.md' },
+  { id: 'tech-evaluator', type: 'skill', source: '.agents/skills/tech-evaluator/SKILL.md', fileName: 'tech-evaluator/SKILL.md' },
+  { id: 'tech-evaluator-adr-template', type: 'skill', source: '.agents/skills/tech-evaluator/references/ADR_TEMPLATE.md', fileName: 'tech-evaluator/references/ADR_TEMPLATE.md' }
 ];
 
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+function toProjectionFileName(resource, projectionType, targetId) {
+  if (targetId === 'codex' && projectionType === 'skills' && resource.type === 'workflow') {
+    return resource.id === 'quickstart'
+      ? 'anws-system/SKILL.md'
+      : `anws-system/references/${resource.id}.md`;
+  }
+  if (projectionType === 'commands') {
+    return `${resource.id}.md`;
+  }
+  if (projectionType === 'prompts') {
+    return targetId === 'copilot' ? `${resource.id}.prompt.md` : `${resource.id}.md`;
+  }
+  if (projectionType === 'agents') {
+    return `${resource.id}.md`;
+  }
+  return resource.fileName;
+}
+
+function buildProjectionEntries(targetId) {
+  const target = getTarget(targetId);
+  const typeMap = target.projectionTypes;
+
+  return RESOURCE_REGISTRY.flatMap((resource) => {
+    const projectionTypes = typeMap[resource.type];
+    if (!projectionTypes) {
+      return [];
+    }
+
+    return toArray(projectionTypes).map((projectionType) => {
+      const outputFileName = toProjectionFileName(resource, projectionType, target.id);
+      return {
+        ...resource,
+        projectionType,
+        outputRoot: target.projections[projectionType],
+        outputPath: `${target.projections[projectionType]}/${outputFileName}`
+      };
+    });
+  });
+}
+
+function buildManagedManifest(targetIds = ['antigravity']) {
+  return toArray(targetIds).flatMap((targetId) => {
+    const target = getTarget(targetId);
+    const entries = buildProjectionEntries(target.id).map((entry) => ({
+      ...entry,
+      targetId: target.id,
+      targetLabel: target.label,
+      ownershipKey: `${target.id}:${entry.outputPath}`
+    }));
+
+    if (!target.rootAgentFile) {
+      return entries;
+    }
+
+    return [
+      {
+        id: 'root-agents',
+        type: 'root',
+        source: 'AGENTS.md',
+        fileName: 'AGENTS.md',
+        projectionType: 'rootAgentFile',
+        outputRoot: '.',
+        outputPath: 'AGENTS.md',
+        targetId: target.id,
+        targetLabel: target.label,
+        ownershipKey: `${target.id}:AGENTS.md`
+      },
+      ...entries
+    ];
+  });
+}
+
+function buildProjectionPlan(targetIds = ['antigravity'], resources = RESOURCE_REGISTRY) {
+  return toArray(targetIds).map((targetId) => {
+    const target = getTarget(targetId);
+    const typeMap = target.projectionTypes;
+    const projectionEntries = resources.flatMap((resource) => {
+      const projectionTypes = typeMap[resource.type];
+      if (!projectionTypes) {
+        return [];
+      }
+
+      return toArray(projectionTypes).map((projectionType) => {
+        const outputFileName = toProjectionFileName(resource, projectionType, target.id);
+        const outputPath = `${target.projections[projectionType]}/${outputFileName}`;
+        return {
+          ...resource,
+          projectionType,
+          outputRoot: target.projections[projectionType],
+          outputPath,
+          targetId: target.id,
+          targetLabel: target.label,
+          ownershipKey: `${target.id}:${outputPath}`
+        };
+      });
+    });
+
+    const managedFiles = target.rootAgentFile
+      ? ['AGENTS.md', ...projectionEntries.map((item) => item.outputPath)]
+      : projectionEntries.map((item) => item.outputPath);
+
+    return {
+      target,
+      targetId: target.id,
+      targetLabel: target.label,
+      managedFiles,
+      userProtectedFiles: buildUserProtectedFiles(target.id),
+      projectionEntries,
+      ownership: projectionEntries.map((item) => item.ownershipKey)
+    };
+  });
+}
+
+function buildManagedFiles(targetId = 'antigravity') {
+  return buildManagedManifest(targetId).map((item) => item.outputPath);
+}
+
+function buildUserProtectedFiles(targetId = 'antigravity') {
+  const target = getTarget(targetId);
+  return target.rootAgentFile ? ['AGENTS.md'] : [];
+}
+
+function findByType(type) {
+  return RESOURCE_REGISTRY.filter((item) => item.type === type);
+}
+
+const MANAGED_FILES = buildManagedFiles('antigravity');
+
 /**
  * USER_PROTECTED_FILES — 用户保护文件
  *
  * 这些文件在项目初始化后通常会包含特定于项目的配置。
  * anws update 默认会跳过这些文件。
  */
-const USER_PROTECTED_FILES = [
-  'AGENTS.md'
-];
+const USER_PROTECTED_FILES = buildUserProtectedFiles('antigravity');
 
 module.exports = {
+  RESOURCE_REGISTRY,
+  buildManagedManifest,
+  buildProjectionPlan,
+  buildManagedFiles,
+  buildProjectionEntries,
+  buildUserProtectedFiles,
+  findByType,
   MANAGED_FILES,
   USER_PROTECTED_FILES
 };
+
+
+

package/lib/output.js

@@ -16,8 +16,20 @@ const useColor =
   !process.env.NO_COLOR &&
   process.env.TERM !== 'dumb';
 
+const PALETTE = {
+  ink: [242, 244, 246],
+  muted: [159, 166, 174],
+  brand: [127, 181, 182],
+  frost: [242, 244, 246],
+  deep: [31, 34, 38],
+};
+
 // ─── ANSI 转义码 ──────────────────────────────────────────────────────────────
 const c = {
+  brand:  useColor ? '\x1b[38;2;127;181;182m' : '',
+  ink:    useColor ? '\x1b[38;2;242;244;246m' : '',
+  muted:  useColor ? '\x1b[38;2;159;166;174m' : '',
+  deep:   useColor ? '\x1b[38;2;31;34;38m' : '',
   green:  useColor ? '\x1b[32m' : '',
   yellow: useColor ? '\x1b[33m' : '',
   red:    useColor ? '\x1b[31m' : '',
@@ -25,6 +37,151 @@ const c = {
   reset:  useColor ? '\x1b[0m'  : '',
 };
 
+function mixRgb(start, end, ratio) {
+  return [
+    Math.round(start[0] + (end[0] - start[0]) * ratio),
+    Math.round(start[1] + (end[1] - start[1]) * ratio),
+    Math.round(start[2] + (end[2] - start[2]) * ratio),
+  ];
+}
+
+function colorRgb(rgb) {
+  return useColor ? `\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m` : '';
+}
+
+function colorize(text, tone) {
+  if (!useColor || !tone) return text;
+  const color = Array.isArray(tone) ? colorRgb(tone) : tone;
+  return `${color}${text}${c.reset}`;
+}
+
+function visibleLength(text) {
+  return String(text).replace(/\x1b\[[0-9;]*m/g, '').length;
+}
+
+function mixStops(stops, ratio) {
+  if (stops.length === 0) return [255, 255, 255];
+  if (stops.length === 1) return stops[0];
+
+  const clamped = Math.max(0, Math.min(1, ratio));
+  const scaled = clamped * (stops.length - 1);
+  const leftIndex = Math.floor(scaled);
+  const rightIndex = Math.min(stops.length - 1, leftIndex + 1);
+  const localRatio = scaled - leftIndex;
+  return mixRgb(stops[leftIndex], stops[rightIndex], localRatio);
+}
+
+function stylizeAsciiLine(text, rowIndex, rowCount) {
+  if (!useColor) return text;
+
+  const rowRatio = rowCount <= 1 ? 0 : rowIndex / (rowCount - 1);
+  const softenedTop = Math.pow(rowRatio, 1.12);
+  const rowBase = mixStops(
+    [PALETTE.deep, PALETTE.brand, PALETTE.muted, PALETTE.ink],
+    0.08 + softenedTop * 0.8
+  );
+  const center = text.length / 2;
+
+  let output = '';
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === ' ') {
+      output += char;
+      continue;
+    }
+
+    const distance = Math.abs(index - center) / Math.max(1, center);
+    const highlight = Math.max(0, 1 - distance);
+    const horizontalRatio = text.length <= 1 ? 0 : index / (text.length - 1);
+    const sweep = mixStops(
+      [PALETTE.deep, PALETTE.brand, PALETTE.frost, PALETTE.muted, PALETTE.ink],
+      horizontalRatio
+    );
+    const brandLift = mixRgb(rowBase, PALETTE.brand, 0.14 + highlight * 0.16);
+    const cooled = mixRgb(brandLift, sweep, 0.4 + highlight * 0.18);
+    const lowerGlow = Math.max(0, rowRatio - 0.58) / 0.42;
+    const tone = mixRgb(cooled, PALETTE.ink, 0.02 + highlight * 0.16 + lowerGlow * 0.16);
+    output += `${colorRgb(tone)}${char}`;
+  }
+
+  return output + c.reset;
+}
+
+function centerLine(text, width) {
+  const length = visibleLength(text);
+  if (!width || length >= width) return text;
+  const leftPad = Math.max(0, Math.floor((width - length) / 2));
+  return `${' '.repeat(leftPad)}${text}`;
+}
+
+function stylizeTagline(text) {
+  if (!useColor) return text;
+
+  let output = '';
+  const length = text.length;
+  for (let index = 0; index < length; index += 1) {
+    const char = text[index];
+    if (char === ' ') {
+      output += char;
+      continue;
+    }
+
+    const ratio = length <= 1 ? 0 : index / (length - 1);
+    const wave = Math.abs(ratio - 0.5) * 2;
+    const base = mixStops(
+      [PALETTE.deep, PALETTE.brand, PALETTE.muted, PALETTE.ink],
+      ratio
+    );
+    const tone = mixRgb(base, PALETTE.ink, 0.08 + (1 - wave) * 0.18);
+    output += `${colorRgb(tone)}${char}`;
+  }
+
+  return output + c.reset;
+}
+
+function padText(text, width) {
+  const padding = Math.max(0, width - visibleLength(text));
+  return `${text}${' '.repeat(padding)}`;
+}
+
+function drawBox(options = {}) {
+  const title = options.title || '';
+  const lines = Array.isArray(options.lines) ? options.lines : [];
+  const accent = options.accent || PALETTE.brand;
+  const borderTone = options.borderTone || PALETTE.muted;
+  const textTone = options.textTone || c.ink;
+  const minWidth = Number.isInteger(options.minWidth) ? options.minWidth : 20;
+  const innerWidth = Math.max(minWidth, visibleLength(title), ...lines.map((line) => visibleLength(line)));
+  const titleText = title ? ` ${title} ` : '';
+  const top = `╭${titleText}${'─'.repeat(Math.max(0, innerWidth + 2 - visibleLength(titleText)))}╮`;
+  const bottom = `╰${'─'.repeat(innerWidth + 2)}╯`;
+  const body = lines.map((line) => {
+    // 支持分隔线：以 '---' 开头的行渲染为水平分隔线
+    if (line.startsWith('---')) {
+      const sepInner = '─'.repeat(innerWidth);
+      return `${colorize('│', borderTone)}${colorize(sepInner, borderTone)}${colorize('│', borderTone)}`;
+    }
+    const padded = padText(line, innerWidth);
+    return `${colorize('│', borderTone)} ${colorize(padded, textTone)} ${colorize('│', borderTone)}`;
+  });
+
+  return [
+    colorize(top, accent),
+    ...body,
+    colorize(bottom, borderTone)
+  ].join('\n');
+}
+
+function section(title, lines = [], options = {}) {
+  console.log(drawBox({
+    title,
+    lines,
+    accent: options.accent || PALETTE.brand,
+    borderTone: options.borderTone || PALETTE.muted,
+    textTone: options.textTone || c.ink,
+    minWidth: options.minWidth
+  }));
+}
 // ─── 公共输出函数 ─────────────────────────────────────────────────────────────
 
 /** 成功消息（绿色 ✔）*/
@@ -64,16 +221,31 @@ function blank() {
 
 /** 打印 ASCII Logo */
 function logo() {
-  const art = `
-    ___    _   ___      _______
-   /   |  / | / / | /| / / ___/
-  / /| | /  |/ /| |/ |/ /\\__ \\ 
- / ___ |/ /|  / |  /|  /___/ / 
-/_/  |_/_/ |_/  |__/|__//____/ 
-  `;
-  const cyan = useColor ? '\x1b[36m' : '';
-  const reset = useColor ? '\x1b[0m' : '';
-  console.log(`${cyan}${art}${reset}`);
-}
-
-module.exports = { success, warn, error, info, fileLine, skippedLine, blank, logo, c };
+  const terminalWidth = Number.isInteger(process.stdout.columns) ? process.stdout.columns : 0;
+  const art = [
+    '█████╗ ███╗   ██╗██╗    ██╗███████╗',
+    '██╔══██╗████╗  ██║██║    ██║██╔════╝',
+    '███████║██╔██╗ ██║██║ █╗ ██║███████╗',
+    '██╔══██║██║╚██╗██║██║███╗██║╚════██║',
+    '██║  ██║██║ ╚████║╚███╔███╔╝███████║',
+    '╚═╝  ╚═╝╚═╝  ╚═══╝ ╚══╝╚══╝ ╚══════╝',
+  ];
+  const title = art
+    .map((line, index, lines) => {
+      const centered = centerLine(line, terminalWidth);
+      return useColor ? stylizeAsciiLine(centered, index, lines.length) : centered;
+    })
+    .join('\n');
+  const taglineText = centerLine('‹ Axiom · Nexus · Weave · Sovereignty ›', terminalWidth);
+  const tagline = useColor ? stylizeTagline(taglineText) : taglineText;
+
+  console.log(title);
+  console.log(tagline);
+}
+
+module.exports = { success, warn, error, info, fileLine, skippedLine, blank, logo, c, PALETTE, colorRgb, colorize, visibleLength, drawBox, section };
+
+
+
+
+