@chemx/starter-kit 26.9.17-606 → 26.9.20-369

package/cli/audit/extended-visitors.js

@@ -1,13 +1,8 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import * as t from '@babel/types';
 import { RULE_REGISTRY } from './rules-registry.js';
-import { toResultSync } from './rules-helpers.js';
-import {
-  isComponentExtension,
-  isTemplateExtension,
-  isCommentLine
-} from './rules-predicates.js';
+import { checkExtendedTextPatterns } from './extended-text-patterns.js';
+
+export { checkExtendedTextPatterns };
 
 const BARE_BOOLEANS = new Set([
   'loading', 'valid', 'active', 'visible', 'open', 'disabled',
@@ -20,19 +15,6 @@ const BARE_HANDLERS = new Set([
   'reset', 'confirm', 'cancel', 'refresh', 'sync', 'send', 'pay'
 ]);
 
-const SECRET_PATTERNS = [
-  /(['"])(?:sk-[a-zA-Z0-9_-]{24,}|ghp_[a-zA-Z0-9]{30,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z-_]{35})\1/
-];
-
-const FAKE_GREEN_PATTERNS = [
-  /expect\s*\(\s*(true|false|1|0)\s*\)\s*\.\s*to(?:Be|Equal|StrictEqual)\s*\(\s*\1\s*\)/,
-  /assert\s*\.\s*(?:strictEqual|equal|deepEqual)\s*\(\s*(true|false|1|0)\s*,\s*\1\s*\)/,
-  /assert\s*\.\s*ok\s*\(\s*(?:true|1)\s*\)/
-];
-
-const IMG_WITHOUT_ALT_PATTERN = new RegExp(['<', 'img\\b', '(?![^>]*\\balt\\s*=)', '[^>]*>'].join(''), 'i');
-const CLICKABLE_CONTAINER_PATTERN = new RegExp(['<', '(div|span)\\b', '(?![^>]*\\brole\\s*=\\s*[\'"](?:button|link|tab)[\'"])', '[^>]*\\b(?:@click|v-on:click)\\s*='].join(''), 'i');
-
 const SENSITIVE_KEYWORDS = new Set([
   'password', 'passwd', 'secret', 'token', 'apikey', 'api_key',
   'authtoken', 'auth_token', 'accesstoken', 'access_token',
@@ -47,8 +29,14 @@ const isSensitiveName = (name = '') => {
 };
 
 const JAVASCRIPT_URL_REGEX = /^\s*javascript:/i;
-const TABNABBING_TEMPLATE_PATTERN = /<a\b[^>]*\btarget\s*=\s*["']_blank["'][^>]*>/i;
-const JAVASCRIPT_URL_TEMPLATE_PATTERN = /\b(?:href|src|action|formaction)\s*=\s*["']\s*javascript:/i;
+
+const resolvePropertyKeyName = (key) => {
+  const isIdentifier = t.isIdentifier(key);
+  if (isIdentifier) return key.name;
+  const isStringLiteral = t.isStringLiteral(key);
+  if (isStringLiteral) return key.value;
+  return '';
+};
 
 const isSensitiveExpression = (node) => {
   if (!node) return false;
@@ -66,11 +54,7 @@ const isSensitiveExpression = (node) => {
   if (t.isObjectExpression(node)) {
     return node.properties.some((prop) => {
       if (t.isObjectProperty(prop)) {
-        const keyName = t.isIdentifier(prop.key)
-          ? prop.key.name
-          : t.isStringLiteral(prop.key)
-          ? prop.key.value
-          : '';
+        const keyName = resolvePropertyKeyName(prop.key);
         return isSensitiveName(keyName);
       }
       return false;
@@ -82,200 +66,6 @@ const isSensitiveExpression = (node) => {
   return false;
 };
 
-/**
- * Pillar 10: Check for co-located test files for molecule capsules.
- */
-const checkMoleculeCoLocatedTest = (filePath, relativePath, violations) => {
-  const baseName = path.basename(filePath);
-  const ext = path.extname(filePath);
-
-  // Stage 1: Atomic Concept Declarations
-  const isMoleculePath = relativePath.includes('molecules') || baseName.startsWith('m-');
-  const isComponentExt = isComponentExtension(ext);
-  const isTestOrSpecFile = baseName.includes('.spec.') || baseName.includes('.test.');
-
-  // Stage 2: Unified Decision Variable & Early Guard Clause
-  const isCandidateComponent = isMoleculePath && isComponentExt;
-  const isMoleculeComponent = isCandidateComponent && !isTestOrSpecFile;
-  if (!isMoleculeComponent) return;
-
-  const dir = path.dirname(filePath);
-  const [siblings, dirError] = toResultSync(() => (fs.existsSync(dir) ? fs.readdirSync(dir) : []));
-
-  // Stage 1: Atomic Guard Check
-  const hasDirError = Boolean(dirError);
-  const hasSiblings = Boolean(siblings);
-  const canInspectSiblings = !hasDirError && hasSiblings;
-  if (!canInspectSiblings) return;
-
-  const isTestSibling = (fileName) => /\.(test|spec)\.[jt]sx?$/.test(fileName);
-  const hasCoLocatedTest = siblings.some(isTestSibling);
-  if (hasCoLocatedTest) return;
-
-  const meta = RULE_REGISTRY.TEST_MISSING_COLOCATED;
-  violations.push({
-    filePath: relativePath,
-    line: 1,
-    column: 1,
-    hazard: 'Molecule capsule missing co-located test file (*.spec.ts or *.test.ts)',
-    rule: 'TEST_MISSING_COLOCATED',
-    severity: meta.severity,
-    pillar: meta.pillar,
-    directive: meta.directive
-  });
-};
-
-export const checkExtendedTextPatterns = (content, lines, relativePath, filePath, violations) => {
-  checkMoleculeCoLocatedTest(filePath, relativePath, violations);
-
-  const isTestFile = /\.(test|spec)\.[jt]sx?$/.test(filePath);
-  const ext = path.extname(filePath);
-  const isTemplateFile = isTemplateExtension(ext);
-
-  lines.forEach((lineText, idx) => {
-    const lineNum = idx + 1;
-    const trimmed = lineText.trim();
-    const isComment = isCommentLine(trimmed);
-
-    // Pillar 9: Hardcoded Secret Detection
-    const hasEnvReference = trimmed.includes('process.env') || trimmed.includes('import.meta.env');
-    const canScanSecrets = !isComment && !hasEnvReference;
-
-    if (canScanSecrets) {
-      for (const pat of SECRET_PATTERNS) {
-        const matchesSecretPattern = pat.test(lineText);
-        const hasPlaceholder = lineText.includes('dummy') || lineText.includes('placeholder');
-        const isHardcodedSecret = matchesSecretPattern && !hasPlaceholder;
-
-        if (isHardcodedSecret) {
-          const meta = RULE_REGISTRY.SECURITY_HARDCODED_SECRET;
-          violations.push({
-            filePath: relativePath,
-            line: lineNum,
-            column: 1,
-            hazard: 'High-entropy API key or secret token detected in source code',
-            rule: 'SECURITY_HARDCODED_SECRET',
-            severity: meta.severity,
-            pillar: meta.pillar,
-            directive: meta.directive
-          });
-          break;
-        }
-      }
-    }
-
-    // Pillar 9: Unsanitized v-html injection (Vue / HTML templates)
-    const hasVHtml = isTemplateFile && /\bv-html\s*=\s*["']/.test(lineText);
-    if (hasVHtml) {
-      const hasSanitizer = /(?:sanitize|DOMPurify|escapeHtml|filterXSS)/i.test(lineText);
-      const isUnsanitizedVHtml = !hasSanitizer;
-
-      if (isUnsanitizedVHtml) {
-        const meta = RULE_REGISTRY.SECURITY_RAW_HTML_INJECTION;
-        violations.push({
-          filePath: relativePath,
-          line: lineNum,
-          column: 1,
-          hazard: 'Unsanitized HTML injection via v-html detected without DOMPurify',
-          rule: 'SECURITY_RAW_HTML_INJECTION',
-          severity: meta.severity,
-          pillar: meta.pillar,
-          directive: meta.directive
-        });
-      }
-    }
-
-    // Pillar 9: Reverse Tabnabbing in HTML / Vue templates
-    const hasTargetBlank = isTemplateFile && TABNABBING_TEMPLATE_PATTERN.test(lineText);
-    if (hasTargetBlank) {
-      const hasRelProtection = /\brel\s*=\s*["'][^"']*(?:noopener|noreferrer)[^"']*["']/i.test(lineText);
-      if (!hasRelProtection) {
-        const meta = RULE_REGISTRY.SECURITY_REVERSE_TABNABBING;
-        violations.push({
-          filePath: relativePath,
-          line: lineNum,
-          column: 1,
-          hazard: 'External link with target="_blank" missing rel="noopener noreferrer"',
-          rule: 'SECURITY_REVERSE_TABNABBING',
-          severity: meta.severity,
-          pillar: meta.pillar,
-          directive: meta.directive
-        });
-      }
-    }
-
-    // Pillar 9: javascript: pseudo-protocol in HTML / Vue templates
-    const hasJsUrl = isTemplateFile && JAVASCRIPT_URL_TEMPLATE_PATTERN.test(lineText);
-    if (hasJsUrl) {
-      const meta = RULE_REGISTRY.SECURITY_JAVASCRIPT_URL;
-      violations.push({
-        filePath: relativePath,
-        line: lineNum,
-        column: 1,
-        hazard: 'javascript: pseudo-protocol detected in template attribute',
-        rule: 'SECURITY_JAVASCRIPT_URL',
-        severity: meta.severity,
-        pillar: meta.pillar,
-        directive: meta.directive
-      });
-    }
-
-    // Pillar 8: Non-semantic clickable containers in templates (@click on div/span)
-    const hasClickableContainer = isTemplateFile && CLICKABLE_CONTAINER_PATTERN.test(lineText);
-    if (hasClickableContainer) {
-      const meta = RULE_REGISTRY.A11Y_CLICKABLE_NON_SEMANTIC;
-      violations.push({
-        filePath: relativePath,
-        line: lineNum,
-        column: 1,
-        hazard: 'Clickable generic container detected without native button/link semantics',
-        rule: 'A11Y_CLICKABLE_NON_SEMANTIC',
-        severity: meta.severity,
-        pillar: meta.pillar,
-        directive: meta.directive
-      });
-    }
-
-    // Pillar 8: Missing alt attribute on img tags
-    const hasMissingAltImg = isTemplateFile && IMG_WITHOUT_ALT_PATTERN.test(lineText);
-    if (hasMissingAltImg) {
-      const meta = RULE_REGISTRY.A11Y_IMAGE_MISSING_ALT;
-      violations.push({
-        filePath: relativePath,
-        line: lineNum,
-        column: 1,
-        hazard: 'Image element missing alt text attribute',
-        rule: 'A11Y_IMAGE_MISSING_ALT',
-        severity: meta.severity,
-        pillar: meta.pillar,
-        directive: meta.directive
-      });
-    }
-
-    // Pillar 10: Fake green tests (only in spec/test files)
-    const canCheckFakeGreen = isTestFile && !isComment;
-    if (canCheckFakeGreen) {
-      for (const pat of FAKE_GREEN_PATTERNS) {
-        const isFakeGreenMatch = pat.test(lineText);
-        if (isFakeGreenMatch) {
-          const meta = RULE_REGISTRY.TEST_FAKE_GREEN;
-          violations.push({
-            filePath: relativePath,
-            line: lineNum,
-            column: 1,
-            hazard: 'Fake green test assertion detected (asserting literal against itself)',
-            rule: 'TEST_FAKE_GREEN',
-            severity: meta.severity,
-            pillar: meta.pillar,
-            directive: meta.directive
-          });
-          break;
-        }
-      }
-    }
-  });
-};
-
 export const createExtendedVisitors = ({ relativePath, violations }) => {
   return {
     JSXOpeningElement(astPath) {

package/cli/audit.js

@@ -93,6 +93,7 @@ const isSourceFile = (name) => {
 };
 
 export const auditFile = (filePath, relativePath) => {
+  if (!isSourceFile(path.basename(filePath))) return [];
   const content = fs.readFileSync(filePath, 'utf-8');
   return auditCode(content, filePath, relativePath);
 };

package/cli/build/detector.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-const findFileUpward = (fileName, startDir) => {
+export const findFileUpward = (fileName, startDir) => {
   let currentDir = path.resolve(startDir);
   while (true) {
     const candidate = path.join(currentDir, fileName);
@@ -13,18 +13,17 @@ const findFileUpward = (fileName, startDir) => {
   return null;
 };
 
-const resolvePackageManager = (cwd) => {
-  const hasPnpmLock = Boolean(findFileUpward('pnpm-lock.yaml', cwd));
-  const hasYarnLock = Boolean(findFileUpward('yarn.lock', cwd));
-  const hasBunLock = Boolean(findFileUpward('bun.lockb', cwd) || findFileUpward('bun.lock', cwd));
-
-  if (hasPnpmLock) return 'pnpm';
-  if (hasYarnLock) return 'yarn';
-  if (hasBunLock) return 'bun';
-  return 'npm';
+export const findProjectRoot = (startDir = process.cwd()) => {
+  const pkgFile = findFileUpward('package.json', startDir);
+  if (pkgFile) return path.dirname(pkgFile);
+  const chemxDir = findFileUpward('.chemx', startDir);
+  if (chemxDir) return path.dirname(chemxDir);
+  const cardVault = '/home/xopher/www/elysium/apps/my-card-vault';
+  if (fs.existsSync(cardVault)) return cardVault;
+  return startDir;
 };
 
-const loadLocalPackageJson = (cwd) => {
+export const loadLocalPackageJson = (cwd) => {
   const pkgPath = path.join(cwd, 'package.json');
   if (!fs.existsSync(pkgPath)) return null;
   try {
@@ -34,6 +33,31 @@ const loadLocalPackageJson = (cwd) => {
   }
 };
 
+export const resolvePackageManager = (cwd) => {
+  const pkg = loadLocalPackageJson(cwd);
+  if (pkg && typeof pkg.packageManager === 'string') {
+    const pmField = pkg.packageManager.toLowerCase();
+    if (pmField.startsWith('pnpm')) return 'pnpm';
+    if (pmField.startsWith('bun')) return 'bun';
+    if (pmField.startsWith('yarn')) return 'yarn';
+    if (pmField.startsWith('npm')) return 'npm';
+  }
+
+  let currentDir = path.resolve(cwd);
+  while (true) {
+    if (fs.existsSync(path.join(currentDir, 'pnpm-lock.yaml'))) return 'pnpm';
+    if (fs.existsSync(path.join(currentDir, 'bun.lockb')) || fs.existsSync(path.join(currentDir, 'bun.lock'))) return 'bun';
+    if (fs.existsSync(path.join(currentDir, 'yarn.lock'))) return 'yarn';
+    if (fs.existsSync(path.join(currentDir, 'package-lock.json'))) return 'npm';
+
+    const parent = path.dirname(currentDir);
+    if (parent === currentDir) break;
+    currentDir = parent;
+  }
+
+  return 'npm';
+};
+
 export const detectProjectBuildCommand = (customCmd, cwd = process.cwd()) => {
   const hasCustomCommand = Boolean(customCmd && customCmd.trim().length > 0);
   if (hasCustomCommand) return customCmd.trim();
@@ -42,18 +66,11 @@ export const detectProjectBuildCommand = (customCmd, cwd = process.cwd()) => {
   const pkg = loadLocalPackageJson(cwd);
   const scripts = (pkg && pkg.scripts) || {};
 
-  const hasBuildScript = Boolean(scripts.build);
-  const hasBuildPublicScript = Boolean(scripts['build:public']);
-  const hasBuildProdScript = Boolean(scripts['build:prod']);
-
-  if (hasBuildScript) {
-    return pm === 'yarn' ? 'yarn build' : `${pm} run build`;
-  }
-  if (hasBuildPublicScript) {
-    return pm === 'yarn' ? 'yarn build:public' : `${pm} run build:public`;
-  }
-  if (hasBuildProdScript) {
-    return pm === 'yarn' ? 'yarn build:prod' : `${pm} run build:prod`;
+  const scriptCandidates = ['build', 'build:prod', 'build:public', 'bundle'];
+  for (const scriptName of scriptCandidates) {
+    if (scripts[scriptName]) {
+      return pm === 'yarn' ? `yarn ${scriptName}` : `${pm} run ${scriptName}`;
+    }
   }
 
   const hasViteConfig = fs.existsSync(path.join(cwd, 'vite.config.js')) ||

package/cli/build/detector.spec.js

@@ -0,0 +1,81 @@
+import test from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  findFileUpward,
+  resolvePackageManager,
+  detectProjectBuildCommand
+} from './detector.js';
+
+test('detector: resolvePackageManager detects packageManager field in package.json', () => {
+  const tmpDir = path.resolve(process.cwd(), 'scratch/test-detector-pm-field');
+  if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true });
+  fs.mkdirSync(tmpDir, { recursive: true });
+
+  fs.writeFileSync(
+    path.join(tmpDir, 'package.json'),
+    JSON.stringify({ name: 'test-app', packageManager: 'pnpm@9.1.0' }),
+    'utf-8'
+  );
+
+  const pm = resolvePackageManager(tmpDir);
+  assert.strictEqual(pm, 'pnpm');
+
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+test('detector: resolvePackageManager detects upward lockfiles', () => {
+  const tmpDir = path.resolve(process.cwd(), 'scratch/test-detector-lockfile');
+  const subDir = path.join(tmpDir, 'apps/sub-app');
+  if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true });
+  fs.mkdirSync(subDir, { recursive: true });
+
+  fs.writeFileSync(path.join(tmpDir, 'bun.lockb'), '', 'utf-8');
+  fs.writeFileSync(path.join(subDir, 'package.json'), JSON.stringify({ name: 'sub-app' }), 'utf-8');
+
+  const pm = resolvePackageManager(subDir);
+  assert.strictEqual(pm, 'bun');
+
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+test('detector: detectProjectBuildCommand uses custom command verbatim', () => {
+  const cmd = detectProjectBuildCommand('vite build --mode production');
+  assert.strictEqual(cmd, 'vite build --mode production');
+});
+
+test('detector: detectProjectBuildCommand auto-detects from package.json scripts.build', () => {
+  const tmpDir = path.resolve(process.cwd(), 'scratch/test-detector-build-script');
+  if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true });
+  fs.mkdirSync(tmpDir, { recursive: true });
+
+  fs.writeFileSync(
+    path.join(tmpDir, 'package.json'),
+    JSON.stringify({
+      name: 'test-app',
+      packageManager: 'pnpm@9.0.0',
+      scripts: { build: 'vue-tsc --noEmit && vite build' }
+    }),
+    'utf-8'
+  );
+
+  const cmd = detectProjectBuildCommand(null, tmpDir);
+  assert.strictEqual(cmd, 'pnpm run build');
+
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+test('detector: detectProjectBuildCommand falls back to vite when vite.config exists', () => {
+  const tmpDir = path.resolve(process.cwd(), 'scratch/test-detector-vite-fallback');
+  if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true });
+  fs.mkdirSync(tmpDir, { recursive: true });
+
+  fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify({ name: 'test-app' }), 'utf-8');
+  fs.writeFileSync(path.join(tmpDir, 'vite.config.ts'), 'export default {}', 'utf-8');
+
+  const cmd = detectProjectBuildCommand('', tmpDir);
+  assert.strictEqual(cmd, 'npx vite build');
+
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});

package/cli/build.js

@@ -1,9 +1,10 @@
-import { detectProjectBuildCommand } from './build/detector.js';
+import { detectProjectBuildCommand, findProjectRoot } from './build/detector.js';
 import { executeBuild } from './build/executor.js';
 import { parseBuildOutput } from './build/parser.js';
 import { groupBuildDiagnostics } from './build/grouper.js';
 import { formatTerminalBuildReport, formatJsonBuildReport } from './build/reporter.js';
 import { ANSI } from './theme.js';
+import { handleError } from './errors/index.js';
 
 const IGNORED_COMMAND_TOKENS = new Set(['build', 'run', 'wrap']);
 
@@ -21,21 +22,22 @@ const parseCommandFromArgs = (args) => {
 };
 
 export const runBuildAudit = async (rawArgs = [], isCli = false, options = {}) => {
-  const isJson = rawArgs.includes('--json');
+  const isJson = rawArgs.includes('--json') || options.json === true;
   const isSilent = rawArgs.includes('--silent') || options.silent === true;
-  const isRaw = rawArgs.includes('--raw');
-  const isSummary = rawArgs.includes('--summary');
+  const isRaw = rawArgs.includes('--raw') || options.raw === true;
+  const isSummary = rawArgs.includes('--summary') || options.summary === true;
   const shouldPrint = options.print !== false;
+  const cwd = findProjectRoot(options.cwd || process.cwd());
 
-  const customCommand = parseCommandFromArgs(rawArgs);
-  const command = detectProjectBuildCommand(customCommand, process.cwd());
+  const customCommand = parseCommandFromArgs(rawArgs) || options.command;
+  const command = detectProjectBuildCommand(customCommand, cwd);
 
   const shouldPrintStart = shouldPrint && !isJson && !isSilent && !isRaw;
   if (shouldPrintStart) {
     process.stdout.write(`${ANSI.CYAN}Auditing build:${ANSI.RESET} ${ANSI.DIM}${command}${ANSI.RESET}\n`);
   }
 
-  const executionResult = await executeBuild(command, process.cwd(), { raw: isRaw });
+  const executionResult = await executeBuild(command, cwd, { raw: isRaw });
   const rawDiagnostics = parseBuildOutput(executionResult.stdout, executionResult.stderr);
   const report = groupBuildDiagnostics(rawDiagnostics, executionResult);
 
@@ -52,6 +54,26 @@ export const runBuildAudit = async (rawArgs = [], isCli = false, options = {}) =
     process.stdout.write(terminalOutput);
   }
 
+  const isFailedBuild = report.exitCode !== 0;
+  const hasIssueFlag = rawArgs.includes('--prep-issue') || rawArgs.includes('--post-issue');
+  const shouldHandleError = isFailedBuild && (hasIssueFlag || options.postIssue || (isCli && !isJson));
+
+  if (shouldHandleError) {
+    const errorDetails = `Build command failed with exit code ${report.exitCode}: ${command}`;
+    await handleError(new Error(errorDetails), {
+      cwd,
+      command,
+      exitCode: report.exitCode,
+      autoPost: rawArgs.includes('--post-issue') || options.postIssue,
+      silent: isSilent || isJson,
+      context: {
+        totalErrors: report.totalErrors,
+        totalWarnings: report.totalWarnings,
+        categories: report.categories
+      }
+    });
+  }
+
   if (isCli) {
     process.exit(report.exitCode);
   }

package/cli/errors/catcher.js

@@ -0,0 +1,80 @@
+import { copyToClipboard } from '../audit/social-git.js';
+import { formatIssueContent } from './formatter.js';
+import { publishIssue } from './publisher.js';
+import { openBrowser, confirmAction } from '../terminal.js';
+import { resolveTargetIssuesRepo, saveIssueArtifact } from './storage.js';
+
+export { resolveTargetIssuesRepo, saveIssueArtifact };
+
+const promptUserToPublish = async (targetRepo, issue) => {
+  const confirmed = await confirmAction('Post this error report directly to GitHub Issues?', 'Post Issue', 'Skip', false);
+  if (!confirmed) {
+    return { success: false, url: null, issueNumber: null, error: null };
+  }
+
+  const publishResult = await publishIssue(targetRepo, issue.title, issue.body, issue.labels);
+  if (publishResult.success) {
+    process.stdout.write(`\x1b[32m✔ Issue published: ${publishResult.url}\x1b[0m\n`);
+    openBrowser(publishResult.url);
+  } else {
+    copyToClipboard(issue.body);
+    process.stdout.write(`\x1b[33m⚠ Publish failed. Markdown copied to clipboard. Opening browser...\x1b[0m\n`);
+    openBrowser(issue.webUrl);
+  }
+  return publishResult;
+};
+
+export const handleError = async (err, options = {}) => {
+  const cwd = options.cwd || process.cwd();
+  const errorObj = err instanceof Error ? err : new Error(String(err));
+  const targetRepo = resolveTargetIssuesRepo(options, cwd);
+
+  const rawCmd = options.command || process.argv.slice(2).join(' ');
+  const command = rawCmd || 'chemx';
+
+  const report = {
+    message: errorObj.message,
+    name: errorObj.name,
+    stack: errorObj.stack || '',
+    command,
+    cwd,
+    exitCode: options.exitCode ?? 1,
+    timestamp: new Date().toISOString(),
+    nodeVersion: process.version,
+    platform: `${process.platform}-${process.arch}`,
+    chemxVersion: options.chemxVersion || '26.9.17',
+    context: options.context || {}
+  };
+
+  const issue = formatIssueContent(report, targetRepo, options.labels);
+  const savedPath = saveIssueArtifact(cwd, issue, options);
+
+  const hasToken = Boolean(process.env.GH_TOKEN || process.env.GITHUB_TOKEN);
+  const isCiEnv = Boolean(process.env.CI || process.env.GITHUB_ACTIONS);
+  const isExplicitAutoPost = Boolean(options.autoPost || process.env.CHEMX_AUTO_POST_ISSUES === 'true');
+  const isCiAutoPost = isCiEnv && hasToken && options.autoPost !== false;
+  const shouldAutoPost = isExplicitAutoPost || isCiAutoPost;
+
+  let publishResult = { success: false, url: null, issueNumber: null, error: null };
+
+  if (shouldAutoPost) {
+    publishResult = await publishIssue(targetRepo, issue.title, issue.body, issue.labels);
+    if (publishResult.success && !options.silent) {
+      process.stdout.write(`\n\x1b[32m✔ Issue automatically created: ${publishResult.url}\x1b[0m\n`);
+    }
+  } else if (!options.silent) {
+    const isTty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const isInteractive = isTty && !isCiEnv;
+    process.stderr.write(`\n\x1b[31m✕ Command Failed: ${report.message}\x1b[0m\n`);
+    process.stderr.write(`  \x1b[33m• Prepped Issue:\x1b[0m ${issue.webUrl}\n`);
+    if (savedPath) {
+      process.stderr.write(`  \x1b[33m• Local Report:\x1b[0m ${savedPath}\n`);
+    }
+
+    if (isInteractive) {
+      publishResult = await promptUserToPublish(targetRepo, issue);
+    }
+  }
+
+  return { report, issue, publishResult, savedPath };
+};