bluedither 1.0.0

package/bluedither.config.json

@@ -0,0 +1,14 @@
+{
+  "name": "bluedither",
+  "version": "1.0.0",
+  "tokens": "theme/tokens.json",
+  "defaults": "theme/tokens.defaults.json",
+  "schema": "theme/tokens.schema.json",
+  "structure": "theme/structure.json",
+  "rules": "theme/rules.md",
+  "skill": "skill.md",
+  "shaders": ["dist/bluedither-shader.js"],
+  "shaderSources": ["theme/shaders/bluedither-shader.js", "theme/shaders/paper-shaders-bundle.js"],
+  "tuner": "dist/bluedither-tuner.js",
+  "generators": "theme/generators/"
+}

package/cli/bin.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+/**
+ * BlueDither CLI
+ *
+ * Usage:
+ *   bluedither install [target-dir]  — Install theme into a project
+ *   bluedither tune                  — Launch fine-tuner dev server
+ *   bluedither extract [dir] [opts]  — Validate/extract theme package
+ *   bluedither publish               — Validate and prepare for publishing
+ */
+
+import { resolve } from 'path';
+
+const [,, command, ...args] = process.argv;
+
+const HELP = `
+  BlueDither CLI
+
+  Usage:
+    bluedither install [target-dir]     Install theme into a project
+    bluedither tune [--port N]          Launch fine-tuner dev server
+    bluedither extract [dir] [--validate]  Validate theme package completeness
+    bluedither publish                  Validate and prepare for publishing
+
+  Options:
+    --help    Show help for a command
+    --version Show version
+`;
+
+if (!command || command === '--help' || command === '-h') {
+  console.log(HELP);
+  process.exit(0);
+}
+
+if (command === '--version' || command === '-v') {
+  const { readFileSync } = await import('fs');
+  const { dirname } = await import('path');
+  const { fileURLToPath } = await import('url');
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf-8'));
+  console.log(pkg.version);
+  process.exit(0);
+}
+
+const commands = {
+  install: () => import('./commands/install.js'),
+  tune: () => import('./commands/tune.js'),
+  extract: () => import('./commands/extract.js'),
+  publish: () => import('./commands/publish.js'),
+};
+
+if (!commands[command]) {
+  console.error(`Unknown command: ${command}\n`);
+  console.log(HELP);
+  process.exit(1);
+}
+
+const mod = await commands[command]();
+await mod.default(args);

package/cli/commands/extract.js

@@ -0,0 +1,103 @@
+/**
+ * bluedither extract [dir] [--validate]
+ *
+ * Validates theme directory completeness.
+ * Full Paper extraction is planned for Phase 5.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export default async function extract(args) {
+  if (args.includes('--help')) {
+    console.log(`
+  bluedither extract [dir] [--validate]
+
+  Validates theme package completeness in the specified directory.
+  Checks that all required files exist and tokens validate against schema.
+
+  Options:
+    --validate    Run schema validation on tokens.json
+    `);
+    return;
+  }
+
+  const doValidate = args.includes('--validate');
+  const dir = resolve(args.find(a => !a.startsWith('--')) || '.');
+
+  console.log(`Checking theme package in: ${dir}\n`);
+
+  const required = [
+    { path: 'theme/tokens.json', label: 'Tokens' },
+    { path: 'theme/tokens.defaults.json', label: 'Default tokens' },
+    { path: 'theme/tokens.schema.json', label: 'Token schema' },
+    { path: 'theme/structure.json', label: 'Structure contract' },
+    { path: 'theme/rules.md', label: 'Design rules' },
+    { path: 'theme/template/index.html', label: 'HTML template' },
+    { path: 'theme/shaders/bluedither-shader.js', label: 'Shader module' },
+    { path: 'theme/shaders/paper-shaders-bundle.js', label: 'Shader bundle' },
+    { path: 'skill.md', label: 'Skill instructions' },
+    { path: 'bluedither.config.json', label: 'Package manifest' },
+  ];
+
+  const optional = [
+    { path: 'dist/bluedither-tuner.js', label: 'Tuner bundle' },
+    { path: 'dist/bluedither-shader.js', label: 'Shader bundle (dist)' },
+    { path: 'theme/generators/vanilla.md', label: 'Vanilla generator' },
+    { path: 'theme/generators/react.md', label: 'React generator' },
+    { path: 'theme/generators/vue.md', label: 'Vue generator' },
+    { path: 'theme/generators/svelte.md', label: 'Svelte generator' },
+  ];
+
+  let allPresent = true;
+
+  console.log('Required files:');
+  for (const { path, label } of required) {
+    const exists = existsSync(resolve(dir, path));
+    console.log(`  ${exists ? '✓' : '✗'} ${label} (${path})`);
+    if (!exists) allPresent = false;
+  }
+
+  console.log('\nOptional files:');
+  for (const { path, label } of optional) {
+    const exists = existsSync(resolve(dir, path));
+    console.log(`  ${exists ? '✓' : '–'} ${label} (${path})`);
+  }
+
+  // Schema validation
+  if (doValidate) {
+    console.log('\nSchema validation:');
+    const schemaPath = resolve(dir, 'theme', 'tokens.schema.json');
+    const tokensPath = resolve(dir, 'theme', 'tokens.json');
+
+    if (!existsSync(schemaPath) || !existsSync(tokensPath)) {
+      console.log('  ✗ Cannot validate: schema or tokens file missing');
+    } else {
+      try {
+        const Ajv2020 = (await import('ajv/dist/2020.js')).default;
+        const schema = JSON.parse(readFileSync(schemaPath, 'utf-8'));
+        const tokens = JSON.parse(readFileSync(tokensPath, 'utf-8'));
+        const ajv = new Ajv2020({ allErrors: true });
+        const validate = ajv.compile(schema);
+        if (validate(tokens)) {
+          console.log('  ✓ tokens.json passes schema validation');
+        } else {
+          console.log('  ✗ tokens.json failed validation:');
+          for (const err of validate.errors) {
+            console.log(`    - ${err.instancePath || '/'}: ${err.message}`);
+          }
+          allPresent = false;
+        }
+      } catch (e) {
+        console.log(`  ✗ Validation error: ${e.message}`);
+        allPresent = false;
+      }
+    }
+  }
+
+  console.log(`\n${allPresent ? '✓ Package is complete.' : '✗ Package is incomplete — missing required files.'}`);
+  process.exit(allPresent ? 0 : 1);
+}

package/cli/commands/install.js

@@ -0,0 +1,126 @@
+/**
+ * bluedither install [target-dir]
+ *
+ * Installs the BlueDither theme into a target project:
+ * - Detects framework from package.json
+ * - Copies tokens, structure, rules, shader, tuner assets
+ * - Generates a Claude Code command file for invoking the skill
+ */
+
+import { readFileSync, writeFileSync, copyFileSync, mkdirSync, existsSync } from 'fs';
+import { resolve, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BLUEDITHER_ROOT = resolve(__dirname, '..', '..');
+
+function detectFramework(targetDir) {
+  const pkgPath = resolve(targetDir, 'package.json');
+  if (!existsSync(pkgPath)) return { framework: 'vanilla', typescript: false };
+
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+  let framework = 'vanilla';
+  if (deps.next || deps.react || deps['react-dom']) framework = 'react';
+  else if (deps.nuxt || deps.vue) framework = 'vue';
+  else if (deps['@sveltejs/kit'] || deps.svelte) framework = 'svelte';
+
+  const typescript = !!(deps.typescript || existsSync(resolve(targetDir, 'tsconfig.json')));
+
+  return { framework, typescript };
+}
+
+export default async function install(args) {
+  if (args.includes('--help')) {
+    console.log(`
+  bluedither install [target-dir]
+
+  Installs BlueDither theme assets into the target project directory.
+  Defaults to current directory if no target specified.
+
+  Detects the project's framework and copies appropriate files.
+    `);
+    return;
+  }
+
+  const targetDir = resolve(args[0] || '.');
+
+  if (!existsSync(targetDir)) {
+    console.error(`Target directory does not exist: ${targetDir}`);
+    process.exit(1);
+  }
+
+  const { framework, typescript } = detectFramework(targetDir);
+  console.log(`Detected framework: ${framework}${typescript ? ' + TypeScript' : ''}`);
+
+  // Create bluedither directory in target
+  const bdDir = resolve(targetDir, 'bluedither');
+  mkdirSync(bdDir, { recursive: true });
+  mkdirSync(resolve(bdDir, 'shaders'), { recursive: true });
+
+  // Copy core theme files
+  const filesToCopy = [
+    ['theme/tokens.json', 'tokens.json'],
+    ['theme/tokens.defaults.json', 'tokens.defaults.json'],
+    ['theme/tokens.schema.json', 'tokens.schema.json'],
+    ['theme/structure.json', 'structure.json'],
+    ['theme/rules.md', 'rules.md'],
+    ['theme/shaders/bluedither-shader.js', 'shaders/bluedither-shader.js'],
+    ['theme/shaders/paper-shaders-bundle.js', 'shaders/paper-shaders-bundle.js'],
+    ['skill.md', 'skill.md'],
+    ['bluedither.config.json', 'bluedither.config.json'],
+  ];
+
+  // Copy generator file for detected framework
+  filesToCopy.push([`theme/generators/${framework}.md`, `generators/${framework}.md`]);
+  mkdirSync(resolve(bdDir, 'generators'), { recursive: true });
+
+  // Copy bundled tuner if it exists
+  const tunerBundlePath = resolve(BLUEDITHER_ROOT, 'dist', 'bluedither-tuner.js');
+  if (existsSync(tunerBundlePath)) {
+    filesToCopy.push(['dist/bluedither-tuner.js', 'bluedither-tuner.js']);
+  }
+
+  let copied = 0;
+  for (const [src, dest] of filesToCopy) {
+    const srcPath = resolve(BLUEDITHER_ROOT, src);
+    const destPath = resolve(bdDir, dest);
+    if (existsSync(srcPath)) {
+      mkdirSync(dirname(destPath), { recursive: true });
+      copyFileSync(srcPath, destPath);
+      copied++;
+    }
+  }
+
+  console.log(`Copied ${copied} files to ${bdDir}`);
+
+  // Generate Claude Code command file
+  const claudeDir = resolve(targetDir, '.claude', 'commands');
+  mkdirSync(claudeDir, { recursive: true });
+
+  const commandContent = `---
+description: Apply BlueDither theme to this project
+---
+
+Read the skill instructions at bluedither/skill.md and follow them to generate the BlueDither theme for this project.
+
+The theme files are in the bluedither/ directory. The target framework is ${framework}${typescript ? ' with TypeScript' : ''}.
+
+$ARGUMENTS
+`;
+
+  writeFileSync(resolve(claudeDir, 'apply-theme.md'), commandContent);
+  console.log(`Created .claude/commands/apply-theme.md`);
+
+  console.log(`
+  BlueDither installed successfully!
+
+  To apply the theme, use Claude Code:
+    /apply-theme [description of your site]
+
+  To customize visually:
+    Include <script src="bluedither/bluedither-tuner.js"></script> in your page
+    Or run: npx bluedither tune
+  `);
+}

package/cli/commands/publish.js

@@ -0,0 +1,85 @@
+/**
+ * bluedither publish
+ *
+ * Validates the theme package and prepares for publishing.
+ * Full marketplace upload will be added in Phase 6.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+import { execSync } from 'child_process';
+
+export default async function publish(args) {
+  if (args.includes('--help')) {
+    console.log(`
+  bluedither publish
+
+  Validates theme package completeness, runs the build, and prepares
+  the package for publishing.
+
+  Marketplace upload will be available in a future version.
+    `);
+    return;
+  }
+
+  const dir = process.cwd();
+  const configPath = resolve(dir, 'bluedither.config.json');
+
+  if (!existsSync(configPath)) {
+    console.error('No bluedither.config.json found in current directory.');
+    console.error('Run this command from the root of a BlueDither theme project.');
+    process.exit(1);
+  }
+
+  const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+  console.log(`Publishing: ${config.name}@${config.version}\n`);
+
+  // Step 1: Build
+  console.log('Step 1: Building...');
+  try {
+    execSync('npm run build', { cwd: dir, stdio: 'inherit' });
+  } catch {
+    console.error('\n✗ Build failed. Fix errors before publishing.');
+    process.exit(1);
+  }
+
+  // Step 2: Validate package completeness
+  console.log('\nStep 2: Validating package...');
+  const { default: extract } = await import('./extract.js');
+  try {
+    await extract(['--validate']);
+  } catch {
+    // extract calls process.exit on failure
+  }
+
+  // Step 3: Check all config paths point to existing files
+  console.log('\nStep 3: Checking config paths...');
+  const pathFields = ['tokens', 'defaults', 'schema', 'structure', 'rules', 'skill', 'tuner'];
+  let configValid = true;
+  for (const field of pathFields) {
+    if (config[field]) {
+      const exists = existsSync(resolve(dir, config[field]));
+      console.log(`  ${exists ? '✓' : '✗'} ${field}: ${config[field]}`);
+      if (!exists) configValid = false;
+    }
+  }
+  if (config.shaders) {
+    for (const s of config.shaders) {
+      const exists = existsSync(resolve(dir, s));
+      console.log(`  ${exists ? '✓' : '✗'} shader: ${s}`);
+      if (!exists) configValid = false;
+    }
+  }
+
+  if (!configValid) {
+    console.error('\n✗ Config paths point to missing files.');
+    process.exit(1);
+  }
+
+  console.log(`
+  ✓ Package ready for publishing.
+
+  Marketplace upload is not yet available.
+  To publish as an npm package, run: npm publish
+  `);
+}

package/cli/commands/tune.js

@@ -0,0 +1,63 @@
+/**
+ * bluedither tune [--port N]
+ *
+ * Launches the fine-tuner dev server.
+ * Finds the nearest bluedither.config.json or theme/ directory.
+ */
+
+import { existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function findThemeRoot(startDir) {
+  let dir = startDir;
+  while (dir !== dirname(dir)) {
+    if (existsSync(resolve(dir, 'bluedither.config.json'))) return dir;
+    if (existsSync(resolve(dir, 'theme', 'tokens.json'))) return dir;
+    dir = dirname(dir);
+  }
+  return null;
+}
+
+export default async function tune(args) {
+  if (args.includes('--help')) {
+    console.log(`
+  bluedither tune [--port N]
+
+  Launches the fine-tuner dev server for real-time token editing.
+  Searches upward for bluedither.config.json or theme/tokens.json.
+
+  Options:
+    --port N    Port number (default: 3333)
+    `);
+    return;
+  }
+
+  const themeRoot = findThemeRoot(process.cwd());
+
+  if (!themeRoot) {
+    console.error('Could not find a BlueDither theme directory.');
+    console.error('Run this from a directory containing bluedither.config.json or theme/tokens.json.');
+    process.exit(1);
+  }
+
+  const serverPath = resolve(themeRoot, 'fine-tuner', 'server.js');
+
+  if (!existsSync(serverPath)) {
+    // If we're in an installed theme (not the source repo), use the source repo's server
+    const sourceServer = resolve(__dirname, '..', '..', 'fine-tuner', 'server.js');
+    if (!existsSync(sourceServer)) {
+      console.error('Fine-tuner server not found.');
+      process.exit(1);
+    }
+    const child = spawn('node', [sourceServer, ...args], { cwd: themeRoot, stdio: 'inherit' });
+    child.on('exit', (code) => process.exit(code || 0));
+    return;
+  }
+
+  const child = spawn('node', [serverPath, ...args], { cwd: themeRoot, stdio: 'inherit' });
+  child.on('exit', (code) => process.exit(code || 0));
+}