@deneb-ui/cli 2.0.40 → 2.0.42

package/src/arc/component-registry.cjs

@@ -0,0 +1,158 @@
+'use strict';
+
+/**
+ * Deneb ARC — Component Registry
+ *
+ * Master lookup of all known editable components in @deneb-ui/ui.
+ * Used by the AI agent to classify "known vs unknown" components
+ * during `deneb init --ai`.
+ */
+
+const KNOWN_EDITABLE_COMPONENTS = new Set([
+  // ─── Core Text & Primitives ────────────────────────────────────
+  'EditableText',
+  'EditableHeading',
+  'EditableParagraph',
+  'EditableBadge',
+  'EditableQuote',
+  'EditableButton',
+  'EditableImage',
+  'EditableMap',
+  'EditableList',
+  'EditableBox',
+  'EditableGrid',
+  'EditableSection',
+  'EditableDialog',
+
+  // ─── Product & Commerce ────────────────────────────────────────
+  'EditableProductCard',
+  'EditableProductGrid',
+  'EditableProductDetail',
+  'EditableCartDrawer',
+  'EditableFilterSidebar',
+  'EditablePricingCard',
+  'ProductQuickView',
+
+  // ─── Content & Social Proof ────────────────────────────────────
+  'EditableServiceCard',
+  'EditableCard',
+  'EditableTestimonialCard',
+  'EditableTestimonialSection',
+  'EditableCustomerReviews',
+  'EditableGoogleFeedback',
+  'EditableFAQAccordion',
+  'EditableContactForm',
+
+  // ─── Layout & Navigation ───────────────────────────────────────
+  'EditableNavbar',
+  'EditableFooter',
+  'EditableHero',
+  'EditableHeroCentered',
+  'EditableHeroSplit',
+  'EditableAnnouncementBar',
+  'EditableCategoryPills',
+  'StickyMobileBar',
+  'TrustBadges',
+  'CookieConsentBanner',
+
+  // ─── Infrastructure ────────────────────────────────────────────
+  'SiteDataProvider',
+  'ThemeStyles',
+  'ResponsiveBaseStyles',
+  'DenebComponentStyles',
+  'FontLoader',
+  'PreviewField',
+]);
+
+/**
+ * Canonical short-name aliases that Shadcn/HeroUI developers might use.
+ * Maps common short names to their Deneb equivalents.
+ */
+const ALIAS_MAP = {
+  'Button': 'EditableButton',
+  'Card': 'EditableCard',
+  'Dialog': 'EditableDialog',
+  'Text': 'EditableText',
+  'Heading': 'EditableHeading',
+  'Paragraph': 'EditableParagraph',
+  'Badge': 'EditableBadge',
+  'Quote': 'EditableQuote',
+  'Image': 'EditableImage',
+  'Map': 'EditableMap',
+  'Grid': 'EditableGrid',
+  'Section': 'EditableSection',
+  'Box': 'EditableBox',
+  'List': 'EditableList',
+  'ProductCard': 'EditableProductCard',
+  'ProductGrid': 'EditableProductGrid',
+  'ProductDetail': 'EditableProductDetail',
+  'CustomerReviews': 'EditableCustomerReviews',
+  'GoogleFeedback': 'EditableGoogleFeedback',
+  'ServiceCard': 'EditableServiceCard',
+  'PricingCard': 'EditablePricingCard',
+  'TestimonialCard': 'EditableTestimonialCard',
+  'TestimonialSection': 'EditableTestimonialSection',
+  'Testimonials': 'EditableTestimonialSection',
+  'FAQ': 'EditableFAQAccordion',
+  'Accordion': 'EditableFAQAccordion',
+  'ContactForm': 'EditableContactForm',
+  'Navbar': 'EditableNavbar',
+  'Header': 'EditableNavbar',
+  'Footer': 'EditableFooter',
+  'Hero': 'EditableHeroCentered',
+  'HeroSplit': 'EditableHeroSplit',
+  'AnnouncementBar': 'EditableAnnouncementBar',
+  'CategoryPills': 'EditableCategoryPills',
+  'CartDrawer': 'EditableCartDrawer',
+  'FilterSidebar': 'EditableFilterSidebar',
+};
+
+/**
+ * Check if a component name is already covered by @deneb-ui/ui.
+ * Checks both the full Editable* name and common aliases.
+ */
+function isKnownComponent(name) {
+  if (!name || typeof name !== 'string') return false;
+  if (KNOWN_EDITABLE_COMPONENTS.has(name)) return true;
+  if (ALIAS_MAP[name]) return true;
+  // Also check if user passed the Editable-prefixed version
+  if (KNOWN_EDITABLE_COMPONENTS.has(`Editable${name}`)) return true;
+  return false;
+}
+
+/**
+ * Returns the list of all known editable component names.
+ */
+function getKnownComponentNames() {
+  return [...KNOWN_EDITABLE_COMPONENTS];
+}
+
+/**
+ * Given a list of discovered component names from a project scan,
+ * returns { known: string[], unknown: string[] }.
+ */
+function classifyComponents(componentNames) {
+  const known = [];
+  const unknown = [];
+  const seen = new Set();
+
+  for (const name of componentNames) {
+    if (seen.has(name)) continue;
+    seen.add(name);
+    if (isKnownComponent(name)) {
+      known.push(name);
+    } else {
+      unknown.push(name);
+    }
+  }
+
+  return { known, unknown };
+}
+
+module.exports = {
+  KNOWN_EDITABLE_COMPONENTS,
+  ALIAS_MAP,
+  isKnownComponent,
+  getKnownComponentNames,
+  classifyComponents,
+};

package/src/arc/index.cjs

@@ -36,6 +36,9 @@ const {
   findUncoveredVisibleText,
 } = require('./fivora-contract.cjs');
 const printer = require('./printer.cjs');
+const { classifyComponents } = require('./component-registry.cjs');
+const { checkAiReady, adaptComponent, generateDocsPage, loadEnv } = require('./ai-agent.cjs');
+const { checkGithubReady, createComponentPR } = require('./pr-agent.cjs');
 
 function parseArcOptions(raw = {}) {
   return {
@@ -46,6 +49,8 @@ function parseArcOptions(raw = {}) {
     skipInstall: Boolean(raw.skipInstall),
     detectedPages: raw.detectedPages || null,
     json: Boolean(raw.json),
+    aiEnabled: Boolean(raw.aiEnabled),
+    aiDryRun: Boolean(raw.aiDryRun),
   };
 }
 
@@ -224,7 +229,7 @@ function analyzeProjectFiles(profile, graph) {
   return analyses;
 }
 
-function runDenebArc(projectDir, projectName, options = {}) {
+async function runDenebArcAsync(projectDir, projectName, options = {}) {
   const opts = parseArcOptions(options);
   const runId = createRunId();
   const startedAt = new Date().toISOString();
@@ -255,6 +260,133 @@ function runDenebArc(projectDir, projectName, options = {}) {
   );
   printer.printScan(profile, graph, candidateCount, actionCount);
 
+  // ─── AI Agent: Classify & Adapt Unknown Components ──────────
+  let aiResults = [];
+  loadEnv(projectDir);
+  const aiCheck = checkAiReady();
+  if (!aiCheck.ready) {
+    printer.warn(`AI Agent disabled: ${aiCheck.reason}`);
+  } else {
+    const componentNames = (profile.components || []).map((c) => c.name || c.tag).filter(Boolean);
+    const { unknown } = classifyComponents(componentNames);
+
+    if (unknown.length > 0) {
+      printer.printAiDetected(unknown.length);
+
+      for (const componentName of unknown) {
+        const meta = (profile.components || []).find((c) => (c.name || c.tag) === componentName);
+        const absFile = meta?.file ? path.join(projectDir, meta.file) : null;
+        let sourceCode = '';
+        if (absFile && fs.existsSync(absFile)) {
+          try { sourceCode = fs.readFileSync(absFile, 'utf8'); } catch { /* skip */ }
+        }
+        if (!sourceCode) {
+          printer.printAiSkipped(componentName, 'could not read source file');
+          continue;
+        }
+
+        try {
+          const aiResult = await adaptComponent(sourceCode, componentName, profile, {
+            onAttempt: (attempt, max) => printer.printAiAttempt(componentName, attempt, max),
+            onValidationFail: (errors, attempt) => printer.printAiValidationFail(errors, attempt),
+            onSuccess: (attempt) => printer.printAiSuccess(componentName, attempt, 0),
+          });
+
+          if (aiResult.success) {
+            aiResults.push({ componentName, ...aiResult });
+            printer.printAiSuccess(componentName, aiResult.attempts, aiResult.fields.length);
+          } else {
+            printer.printAiSkipped(componentName, aiResult.error || 'failed after max retries');
+          }
+        } catch (err) {
+          printer.printAiSkipped(componentName, err.message);
+        }
+      }
+
+      // Background: Open PRs for successfully adapted components
+      const ghCheck = checkGithubReady();
+      if (ghCheck.ready && aiResults.length > 0) {
+        for (const aiResult of aiResults) {
+          try {
+            const docsResult = await generateDocsPage(aiResult.componentName, aiResult.code, aiResult.fields);
+            const prResult = await createComponentPR({
+              componentName: aiResult.componentName,
+              componentCode: aiResult.code,
+              docsCode: docsResult.success ? docsResult.code : null,
+              editableFields: aiResult.fields,
+              attempts: aiResult.attempts,
+              totalInputTokens: aiResult.totalInputTokens,
+              totalOutputTokens: aiResult.totalOutputTokens,
+              dryRun: opts.aiDryRun,
+            });
+            if (prResult.corePr) {
+              printer.printAiPr('chamikathereal/core → deneb-ui/core', `feat/ai-editable-${aiResult.componentName.toLowerCase()}`, prResult.corePr.number);
+            }
+            if (prResult.uiPr) {
+              printer.printAiPr('chamikathereal/ui → deneb-ui/ui', `feat/ai-docs-${aiResult.componentName.toLowerCase()}`, prResult.uiPr.number);
+            }
+            for (const err of prResult.errors) {
+              printer.warn(`PR: ${err}`);
+            }
+          } catch (err) {
+            printer.warn(`PR creation failed for ${aiResult.componentName}: ${err.message}`);
+          }
+        }
+      } else if (!ghCheck.ready && aiResults.length > 0) {
+        printer.warn(`GitHub PRs skipped: ${ghCheck.reason}`);
+      }
+
+      const totalTokens = aiResults.reduce((n, r) => n + r.totalInputTokens + r.totalOutputTokens, 0);
+      printer.printAiSummary(aiResults.length, unknown.length - aiResults.length, totalTokens);
+    }
+  }
+
+  return runArcTransformations(projectDir, projectName, opts, profile, graph, analyses, runId, startedAt);
+}
+
+function runDenebArcSync(projectDir, projectName, options = {}) {
+  const opts = parseArcOptions(options);
+  const runId = createRunId();
+  const startedAt = new Date().toISOString();
+
+  printer.printBanner(opts.dryRun ? 'dry-run' : opts.explain ? 'explain' : 'run');
+
+  const profile = scanProject(projectDir);
+  if (opts.detectedPages && Array.isArray(opts.detectedPages) && opts.detectedPages.length) {
+    const scannedIds = new Set(profile.routes.map((r) => r.id));
+    for (const page of opts.detectedPages) {
+      if (page && page.id && !scannedIds.has(page.id)) {
+        profile.routes.push(page);
+      }
+    }
+  }
+
+  printer.printProfile(profile);
+  const graph = buildDependencyGraph(profile);
+  const analyses = analyzeProjectFiles(profile, graph);
+
+  const candidateCount = analyses.reduce(
+    (n, a) => n + (a.candidates || []).filter((c) => c.kind !== 'decoration' && c.kind !== 'already-editable' && !c.skip).length,
+    0
+  );
+  const actionCount = analyses.reduce(
+    (n, a) => n + (a.candidates || []).filter((c) => c.operation === 'split-action-contract' || c.kind === 'url').length,
+    0
+  );
+  printer.printScan(profile, graph, candidateCount, actionCount);
+
+  return runArcTransformations(projectDir, projectName, opts, profile, graph, analyses, runId, startedAt);
+}
+
+function runDenebArc(projectDir, projectName, options = {}) {
+  const opts = parseArcOptions(options);
+  if (opts.aiEnabled) {
+    return runDenebArcAsync(projectDir, projectName, options);
+  }
+  return runDenebArcSync(projectDir, projectName, options);
+}
+
+function runArcTransformations(projectDir, projectName, opts, profile, graph, analyses, runId, startedAt) {
   const sourceAbs = profile.jsxFiles.map((f) => path.join(projectDir, f));
   const recipeMatch = matchRecipeV2(projectDir, profile, sourceAbs, opts.recipeName);
   if (recipeMatch.recipe) {

package/src/arc/pr-agent.cjs

@@ -0,0 +1,295 @@
+'use strict';
+
+/**
+ * Deneb ARC — PR Agent
+ *
+ * GitHub API integration for automated Pull Request creation.
+ * Creates branches, commits files, and opens PRs from the user's
+ * personal fork into the upstream deneb-ui organization repos.
+ *
+ * All commits are authored under the configured GITHUB_USERNAME
+ * and GITHUB_EMAIL for full contribution credit.
+ */
+
+const { loadEnv } = require('./ai-agent.cjs');
+
+/**
+ * Get GitHub configuration from environment variables.
+ */
+function getGithubConfig() {
+  return {
+    pat: process.env.GITHUB_PAT || '',
+    username: process.env.GITHUB_USERNAME || 'chamikathereal',
+    email: process.env.GITHUB_EMAIL || 'dmforceeg@gmail.com',
+    org: process.env.GITHUB_ORG || 'deneb-ui',
+    coreRepo: process.env.GITHUB_CORE_REPO || 'core',
+    uiRepo: process.env.GITHUB_UI_REPO || 'ui',
+  };
+}
+
+/**
+ * Check if GitHub integration is ready.
+ * @returns {{ ready: boolean, reason?: string }}
+ */
+function checkGithubReady() {
+  loadEnv();
+  const config = getGithubConfig();
+  if (!config.pat) {
+    return { ready: false, reason: 'GITHUB_PAT not set. Generate a Personal Access Token at https://github.com/settings/tokens with "repo" scope.' };
+  }
+  if (!config.pat.startsWith('ghp_') && !config.pat.startsWith('github_pat_')) {
+    return { ready: false, reason: 'GITHUB_PAT does not look valid (should start with ghp_ or github_pat_).' };
+  }
+  return { ready: true };
+}
+
+/**
+ * Create a GitHub API client using @octokit/rest.
+ * Returns null if the PAT is not configured.
+ */
+function createOctokitClient() {
+  const config = getGithubConfig();
+  if (!config.pat) return null;
+
+  try {
+    const { Octokit } = require('@octokit/rest');
+    return new Octokit({ auth: config.pat });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the SHA of the latest commit on a branch.
+ */
+async function getLatestCommitSha(octokit, owner, repo, branch = 'main') {
+  const { data } = await octokit.repos.getBranch({
+    owner,
+    repo,
+    branch,
+  });
+  return data.commit.sha;
+}
+
+/**
+ * Create a new branch from the latest main.
+ */
+async function createBranch(octokit, owner, repo, branchName, baseSha) {
+  await octokit.git.createRef({
+    owner,
+    repo,
+    ref: `refs/heads/${branchName}`,
+    sha: baseSha,
+  });
+}
+
+/**
+ * Create or update a file in a repository on a specific branch.
+ */
+async function createOrUpdateFile(octokit, owner, repo, branch, filePath, content, commitMessage) {
+  const config = getGithubConfig();
+
+  // Check if file already exists to get its SHA
+  let existingSha;
+  try {
+    const { data } = await octokit.repos.getContent({
+      owner,
+      repo,
+      path: filePath,
+      ref: branch,
+    });
+    existingSha = data.sha;
+  } catch {
+    // File does not exist — will create
+  }
+
+  const params = {
+    owner,
+    repo,
+    path: filePath,
+    message: commitMessage,
+    content: Buffer.from(content, 'utf8').toString('base64'),
+    branch,
+    committer: {
+      name: config.username,
+      email: config.email,
+    },
+    author: {
+      name: config.username,
+      email: config.email,
+    },
+  };
+  if (existingSha) params.sha = existingSha;
+
+  await octokit.repos.createOrUpdateFileContents(params);
+}
+
+/**
+ * Open a Pull Request from the user's fork to the upstream repo.
+ */
+async function openPullRequest(octokit, { upstreamOwner, upstreamRepo, forkOwner, branch, title, body }) {
+  const { data } = await octokit.pulls.create({
+    owner: upstreamOwner,
+    repo: upstreamRepo,
+    title,
+    body,
+    head: `${forkOwner}:${branch}`,
+    base: 'main',
+  });
+  return { number: data.number, url: data.html_url };
+}
+
+/**
+ * Build a PR body with validation results and component details.
+ */
+function buildPrBody({ componentName, editableFields, attempts, totalInputTokens, totalOutputTokens, fingerprint }) {
+  const fieldsTable = editableFields.map((f) => `| \`${f}\` |`).join('\n');
+
+  return `## 🤖 AI-Generated Editable Component: \`Editable${componentName}\`
+
+This component was automatically generated by **Deneb ARC AI Agent** and passed all validation checks.
+
+### Editable Fields Discovered
+| Field Path |
+|---|
+${fieldsTable}
+
+### Validation Results
+- ✅ AST Syntax: Passed
+- ✅ Fivora Contract Markers: Passed
+- ✅ TypeScript Interface: Passed
+- ✅ Design Preservation: Intact
+
+### Generation Stats
+- **Model:** ${process.env.OPENAI_CONTENT_MODEL || 'gpt-4o-mini'}
+- **Attempts:** ${attempts}/3
+- **Tokens:** ${totalInputTokens.toLocaleString()} input / ${totalOutputTokens.toLocaleString()} output
+- **Fingerprint:** \`${fingerprint || 'n/a'}\`
+
+---
+*Generated by Deneb ARC AI Agent — [deneb.fivora.site](https://deneb.fivora.site)*`;
+}
+
+/**
+ * Full PR workflow: create branch → commit files → open PR.
+ *
+ * Opens PRs for both the core repo (component) and the ui repo (docs).
+ *
+ * @param {object} params
+ * @param {string} params.componentName - e.g. "Carousel"
+ * @param {string} params.componentCode - The validated EditableCarousel.tsx code
+ * @param {string} params.docsCode - The generated docs page code (optional)
+ * @param {string[]} params.editableFields - List of editable field paths
+ * @param {number} params.attempts - Number of AI attempts taken
+ * @param {number} params.totalInputTokens - Total tokens used
+ * @param {number} params.totalOutputTokens - Total tokens used
+ * @param {string} [params.fingerprint] - Structural fingerprint
+ * @param {boolean} [params.dryRun=false] - If true, skip actual API calls
+ * @returns {Promise<{ corePr?: { number: number, url: string }, uiPr?: { number: number, url: string }, errors: string[] }>}
+ */
+async function createComponentPR(params) {
+  const {
+    componentName,
+    componentCode,
+    docsCode,
+    editableFields,
+    attempts,
+    totalInputTokens,
+    totalOutputTokens,
+    fingerprint,
+    dryRun = false,
+  } = params;
+
+  const errors = [];
+  let corePr = null;
+  let uiPr = null;
+
+  if (dryRun) {
+    return {
+      corePr: { number: 0, url: '(dry-run — PR not created)' },
+      uiPr: docsCode ? { number: 0, url: '(dry-run — PR not created)' } : null,
+      errors: [],
+    };
+  }
+
+  const octokit = createOctokitClient();
+  if (!octokit) {
+    return { errors: ['GitHub client not available — check GITHUB_PAT and @octokit/rest installation.'] };
+  }
+
+  const config = getGithubConfig();
+  const slugName = componentName.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+  const timestamp = Date.now().toString(36);
+  const prBody = buildPrBody({ componentName, editableFields, attempts, totalInputTokens, totalOutputTokens, fingerprint });
+
+  // ── Core Repo PR ───────────────────────────────────────────────
+  try {
+    const coreBranch = `feat/ai-editable-${slugName}-${timestamp}`;
+    const baseSha = await getLatestCommitSha(octokit, config.username, config.coreRepo);
+    await createBranch(octokit, config.username, config.coreRepo, coreBranch, baseSha);
+
+    // Commit the component file
+    await createOrUpdateFile(
+      octokit,
+      config.username,
+      config.coreRepo,
+      coreBranch,
+      `packages/deneb-ui/src/Editable${componentName}.tsx`,
+      componentCode,
+      `feat(ui): add Editable${componentName} component [AI-generated]`
+    );
+
+    // Open PR to upstream
+    corePr = await openPullRequest(octokit, {
+      upstreamOwner: config.org,
+      upstreamRepo: config.coreRepo,
+      forkOwner: config.username,
+      branch: coreBranch,
+      title: `feat(ui): add Editable${componentName} component [AI-generated]`,
+      body: prBody,
+    });
+  } catch (err) {
+    errors.push(`Core PR failed: ${err.message}`);
+  }
+
+  // ── UI Repo PR (docs page) ─────────────────────────────────────
+  if (docsCode) {
+    try {
+      const uiBranch = `feat/ai-docs-${slugName}-${timestamp}`;
+      const uiBaseSha = await getLatestCommitSha(octokit, config.username, config.uiRepo);
+      await createBranch(octokit, config.username, config.uiRepo, uiBranch, uiBaseSha);
+
+      // Commit the docs page
+      await createOrUpdateFile(
+        octokit,
+        config.username,
+        config.uiRepo,
+        uiBranch,
+        `src/app/docs/components/editable-${slugName}/page.tsx`,
+        docsCode,
+        `docs: add Editable${componentName} documentation [AI-generated]`
+      );
+
+      // Open PR to upstream
+      uiPr = await openPullRequest(octokit, {
+        upstreamOwner: config.org,
+        upstreamRepo: config.uiRepo,
+        forkOwner: config.username,
+        branch: uiBranch,
+        title: `docs: add Editable${componentName} documentation [AI-generated]`,
+        body: prBody,
+      });
+    } catch (err) {
+      errors.push(`UI docs PR failed: ${err.message}`);
+    }
+  }
+
+  return { corePr, uiPr, errors };
+}
+
+module.exports = {
+  getGithubConfig,
+  checkGithubReady,
+  createComponentPR,
+  buildPrBody,
+};

package/src/arc/printer.cjs

@@ -163,6 +163,45 @@ function printRollback(reason) {
   console.log(`${C.dim}${reason}${C.reset}\n`);
 }
 
+// ─── AI Agent Progress Messages ──────────────────────────────────
+
+function printAiDetected(unknownCount) {
+  console.log(`\n  ${C.cyan}⚡${C.reset} ${C.bold}AI Agent:${C.reset} Detected ${unknownCount} unknown component${unknownCount > 1 ? 's' : ''}`);
+}
+
+function printAiAttempt(componentName, attempt, maxRetries) {
+  console.log(`  ${C.cyan}⚡${C.reset} Adapting ${C.bold}<${componentName} />${C.reset}... attempt ${attempt}/${maxRetries}`);
+}
+
+function printAiValidationFail(errors, attempt) {
+  for (const err of errors.slice(0, 3)) {
+    console.log(`    ${C.red}❌${C.reset} ${err}`);
+  }
+  if (errors.length > 3) {
+    console.log(`    ${C.dim}... ${errors.length - 3} more errors${C.reset}`);
+  }
+}
+
+function printAiSuccess(componentName, attempt, fieldsCount) {
+  console.log(`    ${C.green}✅${C.reset} All checks passed! (${fieldsCount} editable field${fieldsCount !== 1 ? 's' : ''})`);
+}
+
+function printAiSkipped(componentName, reason) {
+  console.log(`  ${C.yellow}⚠${C.reset} Skipped ${C.bold}<${componentName} />${C.reset}: ${reason}`);
+}
+
+function printAiPr(repoName, branchName, prNumber) {
+  if (prNumber === 0) {
+    console.log(`  ${C.cyan}📦${C.reset} ${C.dim}(dry-run)${C.reset} ${repoName}: ${branchName}`);
+  } else {
+    console.log(`  ${C.cyan}📦${C.reset} PR opened: ${C.bold}${repoName}${C.reset} (#${prNumber})`);
+  }
+}
+
+function printAiSummary(adapted, skipped, totalTokens) {
+  console.log(`\n  ${C.cyan}⚡${C.reset} AI Agent Summary: ${C.green}${adapted} adapted${C.reset}, ${C.yellow}${skipped} skipped${C.reset}, ~${totalTokens.toLocaleString()} tokens used`);
+}
+
 module.exports = {
   printBanner,
   printProfile,
@@ -177,6 +216,13 @@ module.exports = {
   printUncoveredText,
   printDeveloperNextSteps,
   printRollback,
+  printAiDetected,
+  printAiAttempt,
+  printAiValidationFail,
+  printAiSuccess,
+  printAiSkipped,
+  printAiPr,
+  printAiSummary,
   ok,
   warn,
   info,

package/src/arc/version.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 const ARC_NAME = 'Deneb ARC';
-const ARC_FULL_NAME = 'Deneb Adaptive Refactoring Compiler';
-const ARC_VERSION = '1.1.0';
+const ARC_FULL_NAME = 'Deneb Adaptive Refactoring Compiler — AI-Augmented';
+const ARC_VERSION = '2.0.0';
 const SCHEMA_VERSION = 2;
 const ENGINE_ID = 'deneb-arc';