juxscript 1.0.0 → 1.0.1

package/bin/cli.js

@@ -10,11 +10,36 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+// CLEAR PATH CONTRACT
+const PATHS = {
+  // Where jux package is installed (in node_modules/juxscript or local dev)
+  packageRoot: path.resolve(__dirname, '..'),
+  
+  // Where the user's project is (where they run `npx jux`)
+  projectRoot: process.cwd(),
+  
+  // Where jux lib files are (components, layouts, etc.)
+  get juxLib() {
+    return path.join(this.packageRoot, 'lib');
+  },
+  
+  // Where user's dist output goes
+  get projectDist() {
+    return path.join(this.projectRoot, 'dist');
+  }
+};
+
+console.log('📍 JUX Paths:');
+console.log(`   Package: ${PATHS.packageRoot}`);
+console.log(`   Project: ${PATHS.projectRoot}`);
+console.log(`   Lib: ${PATHS.juxLib}`);
+console.log(`   Dist: ${PATHS.projectDist}\n`);
+
 const command = process.argv[2];
-const projectRoot = process.cwd();
-const distDir = path.join(projectRoot, 'dist');
 
 function findJuxFiles(dir, fileList = []) {
+  if (!fs.existsSync(dir)) return fileList;
+  
   const files = fs.readdirSync(dir);
   
   files.forEach(file => {
@@ -34,7 +59,7 @@ function findJuxFiles(dir, fileList = []) {
 }
 
 async function loadConfig() {
-  const configPath = path.join(projectRoot, 'jux.config.js');
+  const configPath = path.join(PATHS.projectRoot, 'jux.config.js');
   
   if (fs.existsSync(configPath)) {
     try {
@@ -53,41 +78,45 @@ async function buildProject(isServe = false) {
   console.log('🔨 Building JUX project...\n');
   
   try {
-    if (fs.existsSync(distDir)) {
-      fs.rmSync(distDir, { recursive: true, force: true });
+    // Clean and create dist
+    if (fs.existsSync(PATHS.projectDist)) {
+      fs.rmSync(PATHS.projectDist, { recursive: true, force: true });
     }
-    fs.mkdirSync(distDir, { recursive: true });
+    fs.mkdirSync(PATHS.projectDist, { recursive: true });
 
-    // Step 1: Generate documentation FIRST
+    // Step 1: Generate documentation from jux lib
     console.log('📚 Generating documentation...');
     try {
-      await generateDocs(projectRoot);
+      await generateDocs(PATHS.juxLib);
       console.log('✅ Documentation generated\n');
     } catch (error) {
       console.warn('⚠️  Failed to generate docs:', error.message);
     }
 
-    // Step 2: Copy lib/ to dist/lib/ (includes docs-data.json)
-    await copyLibToOutput(projectRoot, distDir);
+    // Step 2: Copy jux lib to project dist
+    await copyLibToOutput(PATHS.juxLib, PATHS.projectDist);
     
-    // Step 3: Copy project assets (CSS, JS) from project root
-    await copyProjectAssets(projectRoot, distDir);
+    // Step 3: Copy project assets (CSS, JS)
+    await copyProjectAssets(PATHS.projectRoot, PATHS.projectDist);
 
-    // Step 4: Find and compile project .jux files
-    const projectJuxFiles = findJuxFiles(projectRoot);
+    // Step 4: Compile project .jux files
+    const projectJuxFiles = findJuxFiles(PATHS.projectRoot);
     console.log(`Found ${projectJuxFiles.length} project .jux file(s)\n`);
 
     for (const file of projectJuxFiles) {
       try {
-        await compileJuxFile(file, { distDir, projectRoot, isServe });
+        await compileJuxFile(file, {
+          distDir: PATHS.projectDist,
+          projectRoot: PATHS.projectRoot,
+          isServe
+        });
       } catch (err) {
         console.error(`Error compiling ${file}:`, err.message);
       }
     }
 
-    // Step 5: Find and compile vendor layout .jux files
-    const libRoot = path.resolve(projectRoot, '../lib');
-    const layoutsDir = path.join(libRoot, 'layouts');
+    // Step 5: Compile vendor layouts
+    const layoutsDir = path.join(PATHS.juxLib, 'layouts');
     
     if (fs.existsSync(layoutsDir)) {
       console.log('\n📐 Compiling vendor layouts...');
@@ -96,11 +125,11 @@ async function buildProject(isServe = false) {
       
       for (const file of vendorJuxFiles) {
         try {
-          const relPath = path.relative(libRoot, file);
+          const relPath = path.relative(PATHS.juxLib, file);
           
           await compileJuxFile(file, { 
-            distDir: path.join(distDir, 'lib'),
-            projectRoot: libRoot, 
+            distDir: path.join(PATHS.projectDist, 'lib'),
+            projectRoot: PATHS.juxLib,
             isServe 
           });
           
@@ -114,6 +143,7 @@ async function buildProject(isServe = false) {
     console.log(`\n✅ Built ${projectJuxFiles.length} project file(s) + layouts\n`);
   } catch (err) {
     console.error('❌ Build error:', err.message);
+    console.error(err.stack);
     process.exit(1);
   }
 }
@@ -121,13 +151,10 @@ async function buildProject(isServe = false) {
 (async () => {
   if (command === 'build') {
     await buildProject(false);
-    console.log(`✅ Build complete: ${distDir}`);
+    console.log(`✅ Build complete: ${PATHS.projectDist}`);
     
   } else if (command === 'serve') {
-    // Build first
-    await buildProject(true); // isServe = true
-    
-    // Start server with watcher
+    await buildProject(true);
     const config = await loadConfig();
     await start(3000, config);
     
@@ -138,7 +165,6 @@ JUX CLI - A JavaScript UX authorship platform
 Usage:
   npx jux build              Compile all .jux files to HTML/CSS/JS
   npx jux serve [port]       Start dev server with hot reload (default: 3000)
-                             Builds automatically if dist/ doesn't exist
 
 Examples:
   npx jux build              Build for production

package/lib/components/docs-data.json

@@ -1207,5 +1207,5 @@
     }
   ],
   "version": "1.0.0",
-  "lastUpdated": "2026-01-16T19:58:49.958Z"
+  "lastUpdated": "2026-01-16T22:00:11.522Z"
 }

package/machinery/doc-generator.js

@@ -4,10 +4,15 @@ import { glob } from 'glob';
 
 /**
  * Generate documentation from TypeScript component files
+ * 
+ * @param {string} juxLibPath - Absolute path to jux/lib directory
  */
-export async function generateDocs(projectRoot) {
-  const libRoot = path.resolve(projectRoot, '../lib');
-  const componentsDir = path.join(libRoot, 'components');
+export async function generateDocs(juxLibPath) {
+  const componentsDir = path.join(juxLibPath, 'components');
+  
+  if (!fs.existsSync(componentsDir)) {
+    throw new Error(`Components directory not found: ${componentsDir}`);
+  }
   
   console.log(`  Scanning: ${componentsDir}`);
   
@@ -15,7 +20,7 @@ export async function generateDocs(projectRoot) {
   const componentFiles = glob.sync('*.ts', {
     cwd: componentsDir,
     absolute: true,
-    ignore: ['reactivity.js', 'error-handler.ts', 'docs.ts']
+    ignore: ['reactivity.ts', 'error-handler.ts']
   });
 
   console.log(`  Found ${componentFiles.length} component files`);
@@ -62,23 +67,14 @@ function parseComponentFile(content, filePath) {
   const fileName = path.basename(filePath, '.ts');
   const className = fileName.charAt(0).toUpperCase() + fileName.slice(1);
   
-  // Extract category from file content or infer
   const category = inferCategory(className, content);
-  
-  // Extract description from class JSDoc
   const descMatch = content.match(/\/\*\*\s*\n\s*\*\s*([^\n*]+)/);
   const description = descMatch ? descMatch[1].trim() : `${className} component`;
-  
-  // Extract constructor/factory pattern
   const factoryMatch = content.match(/export function\s+\w+\(([^)]*)\)/);
   const constructorSig = factoryMatch 
     ? `jux.${fileName}(${factoryMatch[1]})`
     : `new ${className}()`;
-  
-  // Extract fluent methods
   const fluentMethods = extractFluentMethods(content, className);
-  
-  // Extract usage example from JSDoc
   const exampleMatch = content.match(/\*\s+Usage:\s*\n\s*\*\s+(.+?)(?:\n|$)/);
   let example = exampleMatch 
     ? exampleMatch[1].trim()
@@ -99,28 +95,14 @@ function parseComponentFile(content, filePath) {
  */
 function extractFluentMethods(content, className) {
   const methods = [];
-  
-  // Match method patterns: methodName(params): this
   const methodRegex = /^\s*(\w+)\(([^)]*)\):\s*this\s*\{/gm;
   let match;
   
   while ((match = methodRegex.exec(content)) !== null) {
     const methodName = match[1];
     const params = match[2];
-    
-    // Skip private methods and constructor
     if (methodName.startsWith('_') || methodName === 'constructor') continue;
-    
-    // Clean up params
-    const cleanParams = params
-      .split(',')
-      .map(p => {
-        const parts = p.trim().split(':');
-        return parts[0].trim();
-      })
-      .filter(p => p)
-      .join(', ');
-    
+    const cleanParams = params.split(',').map(p => p.trim().split(':')[0].trim()).filter(p => p).join(', ');
     methods.push({
       name: methodName,
       params: cleanParams ? `(${cleanParams})` : '()',
@@ -129,7 +111,6 @@ function extractFluentMethods(content, className) {
     });
   }
   
-  // Also look for render methods
   const renderMatch = content.match(/^\s*render\(([^)]*)\):\s*(\w+)/m);
   if (renderMatch && !methods.find(m => m.name === 'render')) {
     methods.push({
@@ -149,12 +130,7 @@ function extractFluentMethods(content, className) {
 function inferCategory(name, content) {
   const dataComponents = ['Table', 'List', 'Chart', 'Data'];
   const coreComponents = ['App', 'Layout', 'Theme', 'Style', 'Script', 'Import'];
-  
-  if (dataComponents.some(dc => name.includes(dc))) {
-    return 'Data Components';
-  }
-  if (coreComponents.includes(name)) {
-    return 'Core';
-  }
+  if (dataComponents.some(dc => name.includes(dc))) return 'Data Components';
+  if (coreComponents.includes(name)) return 'Core';
   return 'UI Components';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juxscript",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "type": "module",
   "description": "A JavaScript UX authorship platform",
   "main": "lib/jux.js",