decantr 0.9.0

package/README.md

@@ -0,0 +1,229 @@
+# decantr
+
+[![CI](https://github.com/decantr-ai/decantr/actions/workflows/ci.yml/badge.svg)](https://github.com/decantr-ai/decantr/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/decantr)](https://www.npmjs.com/package/decantr)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+AI-first web framework. Zero dependencies. Native JS/CSS/HTML. v0.4.2
+
+Decantr is designed for LLMs to generate, read, and maintain — not for human readability. Every API is optimized for token efficiency: terse atomic CSS atoms, proxy-based tag functions, and a machine-readable registry so agents can look up props and exports without parsing source files.
+
+## Quick Start
+
+```bash
+npx decantr init my-app
+cd my-app
+npm install
+npx decantr dev
+```
+
+## Architecture
+
+```
+decantr/core        — h(), text(), cond(), list(), mount(), onMount, onDestroy, ErrorBoundary, Portal, Suspense, Transition
+decantr/state       — createSignal, createEffect, createMemo, createStore, batch, createContext, createHistory, createRoot, on
+decantr/data        — createQuery, createMutation, createEntityStore, createURLSignal, createWebSocket, createPersisted
+decantr/router      — createRouter, link, navigate, useRoute, useSearchParams (hash + history modes, nested routes, guards)
+decantr/form        — createForm, validators, useFormField, fieldArray
+decantr/css         — css(), define(), setStyle(), setMode(), setShape(), 1000+ atomic CSS utilities
+decantr/tags        — Proxy-based tag functions (div, p, span...) — ~25% fewer tokens than h()
+decantr/components  — 100+ UI components (form, display, layout, overlay, feedback, chart, typography)
+decantr/test        — render, fire, flush + node:test re-exports
+```
+
+## Features
+
+- **Zero dependencies** — Pure JavaScript, CSS, HTML
+- **Signal-based reactivity** — Fine-grained DOM updates, no virtual DOM
+- **Direct DOM rendering** — `h()` / `tags` create real elements, no diffing
+- **100+ components** — Form, display, layout, overlay, feedback, chart, typography
+- **Atomic CSS engine** — 1000+ `_`-prefixed utility atoms via `css()`
+- **Style + Mode system** — 5 visual styles x light/dark/auto modes, 170+ design tokens
+- **Machine-readable registry** — JSON specs for 100+ components, 49 patterns, 7 archetypes, recipes
+- **Router** — Hash or History API, nested routes, guards, lazy loading
+- **Form system** — Reactive forms with 10 built-in validators and field arrays
+- **Build tooling** — Tree shaking, code splitting, source maps, CSS purging, incremental builds
+
+## Component Pattern
+
+Every component is a function that returns an HTMLElement:
+
+```javascript
+import { tags } from 'decantr/tags';
+import { text } from 'decantr/core';
+import { createSignal } from 'decantr/state';
+import { css } from 'decantr/css';
+
+const { div, button, span } = tags;
+
+export function Counter({ initial = 0 } = {}) {
+  const [count, setCount] = createSignal(initial);
+  return div({ class: css('_flex _gap2 _p4 _aic') },
+    button({ onclick: () => setCount(c => c - 1) }, '-'),
+    span(text(() => String(count()))),
+    button({ onclick: () => setCount(c => c + 1) }, '+')
+  );
+}
+```
+
+## CLI Commands
+
+```bash
+decantr init [name]       # Scaffold a new project
+decantr dev               # Start dev server with hot reload
+decantr build             # Production build
+decantr test              # Run tests
+decantr test --watch      # Watch mode
+decantr validate          # Validate decantr.essence.json
+decantr lint              # Code quality gates
+decantr a11y              # Accessibility audit
+decantr doctor            # Check project health
+decantr generate          # Generate code from essence
+decantr migrate           # Migrate essence between versions
+```
+
+## MCP Server
+
+Decantr ships a built-in [Model Context Protocol](https://modelcontextprotocol.io) server that exposes 9 read-only tools for querying the component registry, resolving atomic CSS classes, validating project essence files, and searching across the full design system. The server runs locally via stdio — no data is collected, transmitted, or stored externally.
+
+### Start the server
+
+```bash
+npx decantr mcp
+```
+
+### Integration
+
+**Claude Code** (`~/.claude.json`):
+```json
+{
+  "mcpServers": {
+    "decantr": {
+      "command": "npx",
+      "args": ["decantr", "mcp"]
+    }
+  }
+}
+```
+
+**Cursor** (`.cursor/mcp.json`):
+```json
+{
+  "mcpServers": {
+    "decantr": {
+      "command": "npx",
+      "args": ["decantr", "mcp"]
+    }
+  }
+}
+```
+
+**Generic MCP client** (stdio transport):
+```json
+{
+  "command": "npx",
+  "args": ["decantr", "mcp"],
+  "transport": "stdio"
+}
+```
+
+### Examples
+
+**1. Look up a component**
+
+Prompt: *"What props does the Button component accept?"*
+
+Tool call: `lookup_component` with `{ "name": "Button" }`
+
+Response:
+```json
+{
+  "found": true,
+  "name": "Button",
+  "props": {
+    "variant": { "type": "string", "values": ["solid", "outline", "ghost", "link", "destructive"], "default": "solid" },
+    "size": { "type": "string", "values": ["xs", "sm", "md", "lg"], "default": "md" },
+    "disabled": { "type": "boolean", "default": false },
+    "loading": { "type": "boolean", "default": false }
+  }
+}
+```
+
+**2. Resolve atoms**
+
+Prompt: *"What CSS does `_flex _col _gap4 _p4` produce?"*
+
+Tool call: `resolve_atoms` with `{ "atoms": "_flex _col _gap4 _p4" }`
+
+Response:
+```json
+{
+  "total": 4,
+  "valid": 4,
+  "invalid": 0,
+  "atoms": [
+    { "atom": "_flex", "css": "display:flex", "valid": true },
+    { "atom": "_col", "css": "flex-direction:column", "valid": true },
+    { "atom": "_gap4", "css": "gap:var(--d-space-4)", "valid": true },
+    { "atom": "_p4", "css": "padding:var(--d-space-4)", "valid": true }
+  ]
+}
+```
+
+**3. Search the registry**
+
+Prompt: *"Find everything related to tables"*
+
+Tool call: `search_registry` with `{ "query": "table" }`
+
+Response:
+```json
+{
+  "query": "table",
+  "total": 5,
+  "results": [
+    { "type": "component", "name": "DataTable", "score": 80 },
+    { "type": "pattern", "id": "data-table", "name": "Data Table", "score": 90 },
+    { "type": "pattern", "id": "pricing-table", "name": "Pricing Table", "score": 80 },
+    { "type": "component", "name": "Table", "score": 80 },
+    { "type": "pattern", "id": "table-of-contents", "name": "Table of Contents", "score": 80 }
+  ]
+}
+```
+
+### Privacy
+
+The MCP server runs locally via stdio. It reads only local registry JSON files shipped with the package. No data is collected, transmitted, or stored externally.
+
+## Documentation
+
+### Tutorial
+
+A step-by-step guide from zero to deployed app:
+
+1. [Install & Setup](docs/tutorial/01-install.md) — Prerequisites, scaffolding, project structure
+2. [Your First Page](docs/tutorial/02-first-page.md) — Tag functions, atomic CSS, page pattern
+3. [Components](docs/tutorial/03-components.md) — Button, Card, DataTable, and 100+ built-in components
+4. [Styling](docs/tutorial/04-styling.md) — Atoms, styles, modes, design tokens, responsive prefixes
+5. [State](docs/tutorial/05-state.md) — Signals, effects, memos, stores, conditional and list rendering
+6. [Routing](docs/tutorial/06-routing.md) — Routes, guards, nested routes, lazy loading, navigation
+7. [Data Fetching](docs/tutorial/07-data.md) — Queries, mutations, caching, WebSocket, URL-driven state
+8. [Build & Deploy](docs/tutorial/08-deploy.md) — Production builds, static hosting, SPA routing config
+
+### Cookbook
+
+Standalone recipes for common features:
+
+- [SaaS Dashboard](docs/cookbook/dashboard.md) — Sidebar layout, KPI cards, charts, data tables, real-time updates
+- [Authentication](docs/cookbook/auth.md) — Login, registration, protected routes, token management
+- [Internationalization](docs/cookbook/i18n.md) — Multi-language support, locale switcher, RTL layouts
+- [Data Fetching Patterns](docs/cookbook/data-fetching.md) — Caching, optimistic updates, infinite scroll, offline support
+- [Forms](docs/cookbook/forms.md) — Validation, field arrays, multi-step forms, transforms
+
+## Requirements
+
+- Node.js >= 20.0.0
+
+## License
+
+MIT

package/cli/art.js

@@ -0,0 +1,127 @@
+// Truecolor detection
+const NO_COLOR = 'NO_COLOR' in process.env || !process.stdout.isTTY;
+const TRUECOLOR = !NO_COLOR && (
+  process.env.FORCE_COLOR === '3' ||
+  process.env.COLORTERM === 'truecolor' ||
+  process.env.COLORTERM === '24bit' ||
+  /^(iTerm\.app|WezTerm|vscode)$/.test(process.env.TERM_PROGRAM || '')
+);
+
+// Basic ANSI fallbacks
+const WINE = '\x1b[35m';
+const DIM = '\x1b[2m';
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+
+// Auradecantism brand palette (RGB tuples from src/css/styles/auradecantism.js)
+const P = {
+  primary:  [254, 68, 116],   // #FE4474
+  accent:   [10, 243, 235],   // #0AF3EB
+  tertiary: [101, 0, 198],    // #6500C6
+  success:  [0, 195, 136],    // #00C388
+};
+
+function fg(rgb) { return `\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m`; }
+
+function lerp(a, b, t) {
+  return [
+    Math.round(a[0] + (b[0] - a[0]) * t),
+    Math.round(a[1] + (b[1] - a[1]) * t),
+    Math.round(a[2] + (b[2] - a[2]) * t),
+  ];
+}
+
+function gradientText(str, from, to) {
+  if (NO_COLOR) return str;
+  if (!TRUECOLOR) return `${CYAN}${str}${RESET}`;
+  const n = str.length;
+  return str.split('').map((ch, i) =>
+    `${fg(lerp(from, to, n > 1 ? i / (n - 1) : 0))}${ch}`
+  ).join('') + RESET;
+}
+
+// Bottle geometry
+const BOTTLE = [
+  '       ╭─────╮',
+  '       │     │',
+  '       ╰──┬──╯',
+  '          │',
+  '       ╭──┴──╮',
+  '      ╱       ╲',
+  '     ╱         ╲',
+  null, // "decantr" line — special handling
+  '    │           │',
+  '     ╲         ╱',
+  '      ╰───────╯',
+];
+
+function buildBottle() {
+  if (NO_COLOR) {
+    return '\n' + BOTTLE.map((ln, i) =>
+      i === 7 ? '    │  decantr  │' : ln
+    ).join('\n');
+  }
+  const n = BOTTLE.length;
+  return '\n' + BOTTLE.map((ln, i) => {
+    const t = i / (n - 1);
+    const c = TRUECOLOR ? fg(lerp(P.primary, P.tertiary, t)) : WINE;
+    if (i === 7) {
+      const nc = TRUECOLOR ? fg(P.accent) : CYAN;
+      return `${c}    │  ${RESET}${BOLD}${nc}decantr${RESET}${c}  │${RESET}`;
+    }
+    return `${c}${ln}${RESET}`;
+  }).join('\n');
+}
+
+const messages = [
+  'Letting the code breathe...',
+  'Decanting your project...',
+  'Swirling the dependencies...',
+  'Pouring the components...',
+  'A fine vintage of JavaScript...',
+  'Uncorking fresh signals...',
+  'Aerating the DOM...',
+  'Notes of CSS on the palate...',
+  'Bottle-aged to perfection...',
+  'Full-bodied, zero dependencies...'
+];
+
+export function art() {
+  return buildBottle();
+}
+
+export function tagline() {
+  return messages[Math.floor(Math.random() * messages.length)];
+}
+
+export function welcome(version) {
+  const name = NO_COLOR ? 'decantr'
+    : TRUECOLOR ? `${BOLD}${fg(P.primary)}decantr${RESET}`
+    : `${BOLD}decantr${RESET}`;
+  const tl = gradientText(tagline(), P.accent, P.primary);
+  return `${art()}
+
+  ${name} ${DIM}v${version}${RESET} ${DIM}— AI-first web framework${RESET}
+  ${tl}
+`;
+}
+
+export function success(msg) {
+  if (NO_COLOR) return `✓ ${msg}`;
+  const check = TRUECOLOR ? `${fg(P.success)}✓${RESET}` : `${GREEN}✓${RESET}`;
+  return `${check} ${msg}`;
+}
+
+export function info(msg) {
+  if (NO_COLOR) return `→ ${msg}`;
+  const arrow = TRUECOLOR ? `${fg(P.accent)}→${RESET}` : `${CYAN}→${RESET}`;
+  return `${arrow} ${msg}`;
+}
+
+export function heading(msg) {
+  if (NO_COLOR) return `\n  ${msg}\n`;
+  const styled = TRUECOLOR ? `${BOLD}${fg(P.primary)}${msg}${RESET}` : `${BOLD}${msg}${RESET}`;
+  return `\n  ${styled}\n`;
+}

package/cli/commands/a11y.js

@@ -0,0 +1,61 @@
+/**
+ * decantr a11y — Accessibility audit
+ *
+ * Static analysis for common WCAG violations in project source files.
+ * Scans all .js files under src/ and reports errors, warnings, and info.
+ */
+
+import { readdir } from 'node:fs/promises';
+import { join, extname } from 'node:path';
+import { auditFiles, formatIssues } from '../../tools/a11y-audit.js';
+import { heading, success } from '../art.js';
+
+export async function run() {
+  const cwd = process.cwd();
+  console.log(heading('Running accessibility audit...'));
+
+  // Collect all .js files from src/
+  const files = await collectJsFiles(join(cwd, 'src'));
+
+  if (files.length === 0) {
+    console.log('  No source files found in src/');
+    return;
+  }
+
+  console.log(`  Scanning ${files.length} file(s)...\n`);
+
+  const issues = await auditFiles(files);
+  console.log(formatIssues(issues));
+
+  const errors = issues.filter(i => i.severity === 'error');
+  if (errors.length === 0) {
+    console.log(`  ${success('Accessibility audit passed')}\n`);
+  } else {
+    process.exitCode = 1;
+  }
+}
+
+/**
+ * Recursively collect .js files from a directory.
+ * Skips node_modules, dist, and hidden directories.
+ * @param {string} dir
+ * @returns {Promise<string[]>}
+ */
+async function collectJsFiles(dir) {
+  const results = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === 'node_modules' || entry.name === 'dist' || entry.name.startsWith('.')) continue;
+        results.push(...await collectJsFiles(full));
+      } else if (extname(entry.name) === '.js') {
+        results.push(full);
+      }
+    }
+  } catch {
+    // Skip inaccessible directories
+  }
+  return results;
+}

package/cli/commands/audit.js

@@ -0,0 +1,225 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parseArgs } from 'node:util';
+import { audit } from '../../tools/audit.js';
+
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const RESET = '\x1b[0m';
+
+const CHECK = `${GREEN}\u2713${RESET}`;
+const CROSS = `${RED}\u2717${RESET}`;
+const WARN = `${YELLOW}\u26A0${RESET}`;
+
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+
+function sectionHeader(title) {
+  return `  ${BOLD}${CYAN}${title}${RESET}`;
+}
+
+function printEssence(report) {
+  console.log(sectionHeader('Essence'));
+  if (!report.essence) {
+    console.log(`    ${CROSS} No decantr.essence.json found`);
+    return;
+  }
+  const e = report.essence;
+  console.log(`    ${e.valid ? CHECK : CROSS} ${e.valid ? 'Valid' : 'Invalid'}`);
+  if (e.terroir) console.log(`    ${DIM}terroir:${RESET} ${e.terroir}`);
+  if (e.stagesCompleted != null || e.stagesSkipped != null) {
+    const completed = e.stagesCompleted || 0;
+    const skipped = e.stagesSkipped || 0;
+    const total = completed + skipped;
+    console.log(`    ${DIM}stages:${RESET} ${completed}/${total} completed${skipped > 0 ? ` ${YELLOW}(${skipped} skipped)${RESET}` : ''}`);
+  }
+  console.log();
+}
+
+function printCoverage(report) {
+  console.log(sectionHeader('Coverage'));
+  const c = report.coverage;
+  if (!c) { console.log(`    ${DIM}No coverage data${RESET}\n`); return; }
+
+  const pct = c.frameworkDerivedPct != null ? c.frameworkDerivedPct : 0;
+  const pctColor = pct >= 80 ? GREEN : pct >= 50 ? YELLOW : RED;
+  console.log(`    ${DIM}framework-derived:${RESET} ${pctColor}${pct}%${RESET}`);
+
+  if (c.components) {
+    const { used, total } = c.components;
+    console.log(`    ${DIM}components:${RESET} ${used}/${total}`);
+  }
+  if (c.patterns) {
+    const { used, total } = c.patterns;
+    console.log(`    ${DIM}patterns:${RESET} ${used}/${total}`);
+  }
+  if (c.atomCalls != null) {
+    console.log(`    ${DIM}atom calls:${RESET} ${c.atomCalls}`);
+  }
+  if (c.violations != null && c.violations > 0) {
+    console.log(`    ${CROSS} ${RED}${c.violations} violation(s)${RESET}`);
+  }
+  console.log();
+}
+
+function printQuality(report) {
+  console.log(sectionHeader('Quality'));
+  const q = report.quality;
+  if (!q) { console.log(`    ${DIM}No quality data${RESET}\n`); return; }
+
+  const sections = [
+    { key: 'hardcodedCSS', label: 'hardcoded CSS' },
+    { key: 'missingAria', label: 'missing ARIA' },
+    { key: 'leakedListeners', label: 'leaked listeners' }
+  ];
+
+  let clean = true;
+  for (const { key, label } of sections) {
+    const items = q[key];
+    if (!Array.isArray(items) || items.length === 0) continue;
+    clean = false;
+    console.log(`    ${CROSS} ${RED}${items.length}${RESET} ${label}`);
+    for (const item of items) {
+      const loc = item.file ? `${DIM}${item.file}${item.line != null ? `:${item.line}` : ''}${RESET}` : '';
+      const msg = item.message || item.detail || '';
+      console.log(`      ${DIM}-${RESET} ${loc}${msg ? ` ${msg}` : ''}`);
+    }
+  }
+
+  if (clean) {
+    console.log(`    ${CHECK} No violations`);
+  }
+  console.log();
+}
+
+function printGaps(report) {
+  console.log(sectionHeader('Gaps'));
+  const g = report.gaps;
+  if (!g) { console.log(`    ${DIM}No gap data${RESET}\n`); return; }
+
+  let hasGaps = false;
+
+  if (Array.isArray(g.unusedPatterns) && g.unusedPatterns.length > 0) {
+    hasGaps = true;
+    console.log(`    ${WARN} ${YELLOW}${g.unusedPatterns.length}${RESET} unused pattern(s): ${DIM}${g.unusedPatterns.join(', ')}${RESET}`);
+  }
+  if (Array.isArray(g.missingPages) && g.missingPages.length > 0) {
+    hasGaps = true;
+    console.log(`    ${WARN} ${YELLOW}${g.missingPages.length}${RESET} missing page(s): ${DIM}${g.missingPages.join(', ')}${RESET}`);
+  }
+  if (Array.isArray(g.unimplementedTannins) && g.unimplementedTannins.length > 0) {
+    hasGaps = true;
+    console.log(`    ${WARN} ${YELLOW}${g.unimplementedTannins.length}${RESET} unimplemented tannin(s): ${DIM}${g.unimplementedTannins.join(', ')}${RESET}`);
+  }
+
+  if (!hasGaps) {
+    console.log(`    ${CHECK} No gaps detected`);
+  }
+  console.log();
+}
+
+function printBundle(report) {
+  console.log(sectionHeader('Bundle'));
+  const b = report.bundle;
+  if (!b) { console.log(`    ${DIM}No bundle data (run decantr build first)${RESET}\n`); return; }
+
+  const rows = [];
+  for (const asset of ['js', 'css', 'html']) {
+    const entry = b[asset];
+    if (!entry) continue;
+    rows.push({
+      type: asset.toUpperCase(),
+      raw: entry.raw != null ? formatSize(entry.raw) : '-',
+      gzip: entry.gzip != null ? formatSize(entry.gzip) : '-',
+      brotli: entry.brotli != null ? formatSize(entry.brotli) : '-'
+    });
+  }
+
+  if (rows.length === 0) {
+    console.log(`    ${DIM}No bundle data (run decantr build first)${RESET}\n`);
+    return;
+  }
+
+  // Column widths
+  const typeW = 6;
+  const colW = 12;
+  const header = `    ${''.padEnd(typeW)}${'Raw'.padStart(colW)}${'Gzip'.padStart(colW)}${'Brotli'.padStart(colW)}`;
+  console.log(`${DIM}${header}${RESET}`);
+  for (const row of rows) {
+    console.log(`    ${BOLD}${row.type.padEnd(typeW)}${RESET}${row.raw.padStart(colW)}${row.gzip.padStart(colW)}${row.brotli.padStart(colW)}`);
+  }
+
+  if (b.total != null) {
+    console.log(`${DIM}    ${'------'.padEnd(typeW)}${'--------'.padStart(colW)}${'--------'.padStart(colW)}${'--------'.padStart(colW)}${RESET}`);
+    const total = b.total;
+    console.log(`    ${BOLD}${'Total'.padEnd(typeW)}${RESET}${(total.raw != null ? formatSize(total.raw) : '-').padStart(colW)}${(total.gzip != null ? formatSize(total.gzip) : '-').padStart(colW)}${(total.brotli != null ? formatSize(total.brotli) : '-').padStart(colW)}`);
+  }
+  console.log();
+}
+
+export async function run() {
+  const { values } = parseArgs({
+    options: {
+      json: { type: 'boolean', default: false },
+      ci: { type: 'boolean', default: false }
+    },
+    strict: false
+  });
+
+  const cwd = process.cwd();
+  console.log(`\n  ${BOLD}decantr audit${RESET}\n`);
+
+  let report;
+  try {
+    report = await audit(cwd);
+  } catch (err) {
+    console.error(`  ${CROSS} Audit failed: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (values.json) {
+    console.log(JSON.stringify(report, null, 2));
+    if (values.ci && hasViolations(report)) process.exitCode = 1;
+    return;
+  }
+
+  printEssence(report);
+  printCoverage(report);
+  printQuality(report);
+  printGaps(report);
+  printBundle(report);
+
+  // Summary line
+  const violations = countViolations(report);
+  if (violations === 0) {
+    console.log(`  ${CHECK} ${GREEN}Audit passed${RESET}\n`);
+  } else {
+    console.log(`  ${CROSS} ${RED}${violations} violation(s) found${RESET}\n`);
+  }
+
+  if (values.ci && hasViolations(report)) {
+    process.exitCode = 1;
+  }
+}
+
+function countViolations(report) {
+  let count = 0;
+  const q = report.quality;
+  if (!q) return 0;
+  if (Array.isArray(q.hardcodedCSS)) count += q.hardcodedCSS.length;
+  if (Array.isArray(q.missingAria)) count += q.missingAria.length;
+  if (Array.isArray(q.leakedListeners)) count += q.leakedListeners.length;
+  return count;
+}
+
+function hasViolations(report) {
+  return countViolations(report) > 0;
+}

package/cli/commands/build.js

@@ -0,0 +1,38 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export async function run() {
+  const cwd = process.cwd();
+  let config = {
+    build: {
+      outDir: 'dist',
+      inline: false,
+      sourcemap: true,
+      analyze: true,
+      incremental: true,
+      codeSplit: true,
+      purgeCSS: true,
+      treeShake: true
+    }
+  };
+
+  try {
+    const raw = await readFile(join(cwd, 'decantr.config.json'), 'utf-8');
+    const userConfig = JSON.parse(raw);
+    config.build = { ...config.build, ...(userConfig.build || {}) };
+  } catch (e) {
+    // Use defaults
+  }
+
+  // CLI flag overrides
+  const args = process.argv.slice(2);
+  if (args.includes('--no-sourcemap')) config.build.sourcemap = false;
+  if (args.includes('--no-analyze')) config.build.analyze = false;
+  if (args.includes('--no-incremental')) config.build.incremental = false;
+  if (args.includes('--no-code-split')) config.build.codeSplit = false;
+  if (args.includes('--no-purge')) config.build.purgeCSS = false;
+  if (args.includes('--no-tree-shake')) config.build.treeShake = false;
+
+  const { build } = await import('../../tools/builder.js');
+  await build(cwd, config.build);
+}

package/cli/commands/dev.js

@@ -0,0 +1,18 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export async function run() {
+  const cwd = process.cwd();
+  let config = { dev: { port: 3000 } };
+
+  try {
+    const raw = await readFile(join(cwd, 'decantr.config.json'), 'utf-8');
+    config = JSON.parse(raw);
+  } catch (e) {
+    // Use defaults
+  }
+
+  const port = config.dev?.port || 3000;
+  const { startDevServer } = await import('../../tools/dev-server.js');
+  startDevServer(cwd, port);
+}