g360-cli 1.0.0

package/src/commands/audit.js

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { auditor } from '../lib/auditor.js';
+
+export async function audit(projectPath, options) {
+  const { fix = false, verbose = false } = options;
+  const targetDir = path.join(process.cwd(), projectPath);
+  
+  console.log(chalk.bold.cyan('\n🔍 G360 Project Audit\n'));
+  console.log(chalk.gray(`Path: ${targetDir}\n`));
+
+  if (!fs.existsSync(targetDir)) {
+    console.error(chalk.red(`❌ Path not found: ${targetDir}`));
+    return;
+  }
+
+  const results = await auditor.audit(targetDir, { verbose });
+
+  console.log(chalk.yellow('📊 Audit Results:'));
+  console.log(chalk.green(`  Passed: ${results.passed}`));
+  console.log(chalk.red(`  Failed: ${results.failed}`));
+  console.log(chalk.cyan(`  Warnings: ${results.warnings}\n`));
+
+  if (results.issues.length > 0) {
+    console.log(chalk.bold.yellow('Issues Found:'));
+    results.issues.forEach(issue => {
+      const icon = issue.severity === 'error' ? chalk.red('✗') : chalk.yellow('!');
+      console.log(`  ${icon} ${chalk.gray(issue.file)}: ${issue.message}`);
+    });
+    console.log();
+  }
+
+  if (results.passed === results.total && results.warnings === 0) {
+    console.log(chalk.green('✅ Project is G360 compliant!\n'));
+  } else {
+    console.log(chalk.yellow('⚠️  Some issues need attention.\n'));
+  }
+
+  if (fix) {
+    console.log(chalk.cyan('Auto-fix not yet implemented.\n'));
+  }
+}

package/src/commands/bring.js

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { progress } from '../lib/progress.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function bring(asset, options) {
+  const { path: targetPath = '.', dryRun = false, force = false } = options;
+  const targetDir = path.join(process.cwd(), targetPath);
+  const assetsPath = path.join(__dirname, '../assets');
+  
+  console.log(chalk.bold.cyan('\n📦 G360 Asset Manager\n'));
+
+  if (!asset || asset === 'all') {
+    console.log(chalk.yellow('Bringing all G360 assets...\n'));
+    return copyAssets(assetsPath, targetDir, dryRun, force);
+  }
+
+  const assetPath = path.join(assetsPath, asset);
+  
+  if (!fs.existsSync(assetPath)) {
+    console.error(chalk.red(`❌ Asset "${asset}" not found.`));
+    console.log(chalk.gray('\nRun "g360 list assets" to see available assets.'));
+    return;
+  }
+
+  await copyAssets(assetPath, targetDir, dryRun, force);
+}
+
+async function copyAssets(src, dest, dryRun, force) {
+  if (dryRun) {
+    console.log(chalk.yellow('📋 DRY RUN - No files will be copied\n'));
+    return;
+  }
+
+  const progressBar = progress('Copying assets...');
+  
+  try {
+    const items = fs.readdirSync(src);
+    for (const item of items) {
+      const srcPath = path.join(src, item);
+      const destPath = path.join(dest, 'g360', item);
+      
+      if (fs.statSync(srcPath).isDirectory()) {
+        await fs.copy(srcPath, destPath, { overwrite: force });
+      }
+    }
+    
+    progressBar.stop();
+    console.log(chalk.green('\n✅ Assets copied successfully!\n'));
+  } catch (error) {
+    progressBar.stop();
+    console.error(chalk.red(`\n❌ Error: ${error.message}`));
+  }
+}

package/src/commands/clean.js

@@ -0,0 +1,65 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { manifest } from '../lib/manifest.js';
+
+export async function clean(projectPath, options) {
+  const { dryRun = false, force = false } = options;
+  const targetDir = path.join(process.cwd(), projectPath);
+  
+  console.log(chalk.bold.cyan('\n🧹 G360 Clean\n'));
+  console.log(chalk.gray(`Path: ${targetDir}\n`));
+
+  if (!fs.existsSync(targetDir)) {
+    console.error(chalk.red(`❌ Path not found: ${targetDir}`));
+    return;
+  }
+
+  const g360Dir = path.join(targetDir, 'g360');
+  if (!fs.existsSync(g360Dir)) {
+    console.log(chalk.yellow('No g360 assets found to clean.'));
+    return;
+  }
+
+  const assetsToClean = getAssetsToClean(g360Dir);
+  
+  console.log(chalk.yellow('Assets to be removed:'));
+  assetsToClean.forEach(asset => console.log(chalk.gray(`  - ${asset}`)));
+  console.log();
+
+  if (dryRun) {
+    console.log(chalk.yellow('📋 DRY RUN - No files will be removed\n'));
+    return;
+  }
+
+  if (!force) {
+    console.log(chalk.gray('Run with --force to confirm deletion.'));
+    return;
+  }
+
+  try {
+    await fs.remove(g360Dir);
+    await manifest.remove(targetDir);
+    console.log(chalk.green('\n✅ G360 assets cleaned successfully!\n'));
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Error: ${error.message}`));
+  }
+}
+
+function getAssetsToClean(dir, baseDir = dir) {
+  const items = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    const relativePath = path.relative(baseDir, fullPath);
+    
+    if (entry.isDirectory()) {
+      items.push(...getAssetsToClean(fullPath, baseDir));
+    } else {
+      items.push(relativePath);
+    }
+  }
+  
+  return items;
+}

package/src/commands/health.js

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function health(options) {
+  const { verbose = false } = options;
+  
+  console.log(chalk.bold.cyan('\n🏥 G360 Health Check\n'));
+
+  const checks = [];
+
+  checks.push({
+    name: 'Node.js',
+    status: process.version ? 'ok' : 'error',
+    message: process.version
+  });
+
+  const npmPath = process.env.PATH?.includes('npm') || true;
+  checks.push({
+    name: 'npm',
+    status: npmPath ? 'ok' : 'error',
+    message: npmPath ? 'Available' : 'Not found'
+  });
+
+  const assetsPath = path.join(__dirname, '../assets');
+  const hasAssets = fs.existsSync(assetsPath);
+  checks.push({
+    name: 'G360 Assets',
+    status: hasAssets ? 'ok' : 'warn',
+    message: hasAssets ? 'Installed' : 'Run g360 update'
+  });
+
+  const manifest = path.join(process.cwd(), 'g360-manifest.json');
+  const hasManifest = fs.existsSync(manifest);
+  checks.push({
+    name: 'Project Manifest',
+    status: hasManifest ? 'ok' : 'warn',
+    message: hasManifest ? 'Found' : 'Not in a G360 project'
+  });
+
+  console.log(chalk.yellow('System Status:'));
+  checks.forEach(check => {
+    const icon = check.status === 'ok' ? chalk.green('✓') : 
+                 check.status === 'warn' ? chalk.yellow('!') : chalk.red('✗');
+    console.log(`  ${icon} ${check.name}: ${chalk.gray(check.message)}`);
+  });
+
+  const allOk = checks.every(c => c.status !== 'error');
+  console.log();
+  
+  if (allOk) {
+    console.log(chalk.green('✅ System is healthy!\n'));
+  } else {
+    console.log(chalk.red('❌ Some checks failed.\n'));
+  }
+
+  if (verbose) {
+    console.log(chalk.gray('\nAdditional Info:'));
+    console.log(`  CWD: ${process.cwd()}`);
+    console.log(`  Platform: ${process.platform}`);
+    console.log();
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,63 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { manifest } from '../lib/manifest.js';
+import { progress } from '../lib/progress.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function init(name, options) {
+  const { template = 'web-pwa', dir = '.', dryRun = false, force = false } = options;
+  const targetDir = path.join(process.cwd(), dir, name);
+  
+  console.log(chalk.bold.cyan('\n🚀 G360 Project Initialization\n'));
+  console.log(`Project: ${chalk.yellow(name)}`);
+  console.log(`Template: ${chalk.blue(template)}`);
+  console.log(`Target: ${chalk.gray(targetDir)}\n`);
+
+  const templatesPath = path.join(__dirname, '../assets/templates');
+  
+  if (!fs.existsSync(templatesPath)) {
+    console.error(chalk.red('❌ Templates not found. Run: g360 update'));
+    return;
+  }
+
+  const templateDir = path.join(templatesPath, template);
+  
+  if (!fs.existsSync(templateDir)) {
+    console.error(chalk.red(`❌ Template "${template}" not found.`));
+    console.log(chalk.gray('\nAvailable templates:'));
+    const templates = fs.readdirSync(templatesPath);
+    templates.forEach(t => console.log(chalk.gray(`  - ${t}`)));
+    return;
+  }
+
+  if (fs.existsSync(targetDir) && !force) {
+    console.error(chalk.red(`❌ Directory "${name}" already exists. Use --force to overwrite.`));
+    return;
+  }
+
+  if (dryRun) {
+    console.log(chalk.yellow('📋 DRY RUN - No files will be created\n'));
+    console.log(chalk.gray(`Would create: ${targetDir}`));
+    return;
+  }
+
+  const progressBar = progress('Creating project...');
+  
+  try {
+    await fs.copy(templateDir, targetDir);
+    await manifest.init(targetDir, { name, template, version: '1.0.0' });
+    progressBar.stop();
+    
+    console.log(chalk.green('\n✅ Project created successfully!\n'));
+    console.log(chalk.gray('Next steps:'));
+    console.log(`  ${chalk.cyan('cd')} ${name}`);
+    console.log(`  ${chalk.cyan('g360 bring')}`);
+    console.log(`  ${chalk.cyan('g360 present')}\n`);
+  } catch (error) {
+    progressBar.stop();
+    console.error(chalk.red(`\n❌ Error: ${error.message}`));
+  }
+}

package/src/commands/list.js

@@ -0,0 +1,71 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function list(type, options) {
+  const { json = false } = options;
+  const assetsPath = path.join(__dirname, '../assets');
+  
+  console.log(chalk.bold.cyan('\n📋 G360 Assets\n'));
+
+  const assets = {
+    templates: [],
+    components: [],
+    skills: []
+  };
+
+  const templatesPath = path.join(assetsPath, 'templates');
+  const componentsPath = path.join(assetsPath, 'components');
+  const skillsPath = path.join(assetsPath, 'skills');
+  const enginePath = path.join(assetsPath, 'engine');
+
+  if (fs.existsSync(templatesPath)) {
+    assets.templates = fs.readdirSync(templatesPath);
+  }
+  if (fs.existsSync(componentsPath)) {
+    assets.components = fs.readdirSync(componentsPath).filter(f => f.endsWith('.jsx') || f.endsWith('.js'));
+  }
+  if (fs.existsSync(skillsPath)) {
+    assets.skills = fs.readdirSync(skillsPath).filter(f => f.endsWith('.js') || f.endsWith('.mjs'));
+  }
+  if (fs.existsSync(enginePath)) {
+    assets.engine = fs.readdirSync(enginePath).filter(f => f.startsWith('g360-skill-'));
+  }
+
+  if (json) {
+    console.log(JSON.stringify(assets, null, 2));
+    return;
+  }
+
+  if (!type || type === 'all' || type === 'templates') {
+    console.log(chalk.bold.yellow('\n📁 Templates:'));
+    if (assets.templates.length) {
+      assets.templates.forEach(t => console.log(chalk.gray(`  - ${t}`)));
+    } else {
+      console.log(chalk.gray('  No templates found'));
+    }
+  }
+
+  if (!type || type === 'all' || type === 'components') {
+    console.log(chalk.bold.yellow('\n🧩 Components:'));
+    if (assets.components.length) {
+      assets.components.forEach(c => console.log(chalk.gray(`  - ${c}`)));
+    } else {
+      console.log(chalk.gray('  No components found'));
+    }
+  }
+
+  if (!type || type === 'all' || type === 'skills') {
+    console.log(chalk.bold.yellow('\n⚡ Skills:'));
+    if (assets.engine.length) {
+      assets.engine.forEach(s => console.log(chalk.gray(`  - ${s}`)));
+    } else {
+      console.log(chalk.gray('  No skills found'));
+    }
+  }
+
+  console.log();
+}

package/src/commands/present.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function present(projectPath, options) {
+  const { depth = 3 } = options;
+  const targetDir = path.join(process.cwd(), projectPath);
+  
+  console.log(chalk.bold.cyan('\n🗂️  G360 Project Structure\n'));
+  console.log(chalk.gray(`Path: ${targetDir}\n`));
+
+  if (!fs.existsSync(targetDir)) {
+    console.error(chalk.red(`❌ Path not found: ${targetDir}`));
+    return;
+  }
+
+  const manifestPath = path.join(targetDir, 'g360-manifest.json');
+  if (fs.existsSync(manifestPath)) {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+    console.log(chalk.yellow('📋 Project Info:'));
+    console.log(chalk.gray(`  Name: ${manifest.name || 'Unknown'}`));
+    console.log(chalk.gray(`  Template: ${manifest.template || 'Unknown'}`));
+    console.log(chalk.gray(`  Version: ${manifest.version || 'Unknown'}\n`));
+  }
+
+  console.log(chalk.yellow('📁 Structure:'));
+  printTree(targetDir, '', parseInt(depth), true);
+  console.log();
+}
+
+function printTree(dir, prefix, depth, isRoot) {
+  if (depth < 0) return;
+
+  const items = fs.readdirSync(dir, { withFileTypes: true });
+  const dirs = items.filter(i => i.isDirectory() && !i.name.startsWith('.') && i.name !== 'node_modules');
+  const files = items.filter(i => i.isFile() && !i.name.startsWith('.'));
+
+  dirs.forEach((dirItem, index) => {
+    const isLast = index === dirs.length - 1 && files.length === 0;
+    const connector = isLast ? '└── ' : '├── ';
+    console.log(chalk.cyan(`${prefix}${connector}${dirItem.name}/`));
+    
+    const newPrefix = prefix + (isLast ? '    ' : '│   ');
+    printTree(path.join(dir, dirItem.name), newPrefix, depth - 1, false);
+  });
+
+  files.forEach((fileItem, index) => {
+    const isLast = index === files.length - 1;
+    const connector = isLast ? '└── ' : '├── ';
+    const ext = path.extname(fileItem.name);
+    const color = ['.json', '.js', '.jsx', '.ts', '.tsx'].includes(ext) ? chalk.white : chalk.gray;
+    console.log(color(`${prefix}${connector}${fileItem.name}`));
+  });
+}

package/src/commands/update.js

@@ -0,0 +1,29 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+
+export async function update(options) {
+  const { check = false } = options;
+  
+  console.log(chalk.bold.cyan('\n⬆️  G360 Update\n'));
+
+  if (check) {
+    try {
+      const currentVersion = '1.0.0';
+      console.log(chalk.gray(`Current version: ${currentVersion}`));
+      console.log(chalk.gray('Check npm for latest version...'));
+      console.log(chalk.yellow('\nUse: npm install -g g360-cli@latest to update'));
+    } catch (error) {
+      console.error(chalk.red(`Error checking version: ${error.message}`));
+    }
+    return;
+  }
+
+  try {
+    console.log(chalk.yellow('Installing latest g360-cli...\n'));
+    execSync('npm install -g g360-cli', { stdio: 'inherit' });
+    console.log(chalk.green('\n✅ g360-cli updated successfully!\n'));
+  } catch (error) {
+    console.error(chalk.red('\n❌ Update failed. Try:'));
+    console.log(chalk.gray('  npm install -g g360-cli@latest\n'));
+  }
+}

package/src/lib/assets.js

@@ -0,0 +1,38 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export const assets = {
+  path: path.join(__dirname, '../assets'),
+
+  exists(assetPath) {
+    return fs.existsSync(path.join(this.path, assetPath));
+  },
+
+  async copy(assetPath, destPath, options = {}) {
+    const { overwrite = false } = options;
+    const src = path.join(this.path, assetPath);
+    const dest = path.join(destPath, path.basename(assetPath));
+
+    if (!this.exists(assetPath)) {
+      throw new Error(`Asset not found: ${assetPath}`);
+    }
+
+    if (fs.existsSync(dest) && !overwrite) {
+      throw new Error(`Destination already exists: ${dest}`);
+    }
+
+    await fs.copy(src, dest, { overwrite });
+    return dest;
+  },
+
+  list(category) {
+    const categoryPath = path.join(this.path, category);
+    if (!fs.existsSync(categoryPath)) {
+      return [];
+    }
+    return fs.readdirSync(categoryPath);
+  }
+};

package/src/lib/auditor.js

@@ -0,0 +1,67 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const auditor = {
+  async audit(projectDir, options = {}) {
+    const { verbose = false } = options;
+    const results = {
+      passed: 0,
+      failed: 0,
+      warnings: 0,
+      total: 0,
+      issues: []
+    };
+
+    const checks = [
+      { name: 'manifest', check: () => this.checkManifest(projectDir) },
+      { name: 'structure', check: () => this.checkStructure(projectDir) },
+      { name: 'config', check: () => this.checkConfig(projectDir) }
+    ];
+
+    for (const { name, check } of checks) {
+      const result = await check();
+      results.total++;
+      
+      if (result.status === 'pass') {
+        results.passed++;
+      } else if (result.status === 'fail') {
+        results.failed++;
+        results.issues.push({ ...result.issue, severity: 'error' });
+      } else if (result.status === 'warn') {
+        results.warnings++;
+        results.issues.push({ ...result.issue, severity: 'warning' });
+      }
+
+      if (verbose && result.details) {
+        console.log(chalk.gray(`  ${name}: ${result.details}`));
+      }
+    }
+
+    return results;
+  },
+
+  checkManifest(projectDir) {
+    const manifestPath = path.join(projectDir, 'g360-manifest.json');
+    if (fs.existsSync(manifestPath)) {
+      return { status: 'pass', details: 'Manifest found' };
+    }
+    return { status: 'warn', issue: { file: 'g360-manifest.json', message: 'No manifest found' } };
+  },
+
+  checkStructure(projectDir) {
+    const g360Dir = path.join(projectDir, 'g360');
+    if (fs.existsSync(g360Dir)) {
+      return { status: 'pass', details: 'G360 assets directory found' };
+    }
+    return { status: 'warn', issue: { file: 'g360/', message: 'No G360 assets found' } };
+  },
+
+  checkConfig(projectDir) {
+    const configPath = path.join(projectDir, 'g360', 'config');
+    if (fs.existsSync(configPath)) {
+      return { status: 'pass', details: 'Config directory found' };
+    }
+    return { status: 'pass' };
+  }
+};

package/src/lib/checksum.js

@@ -0,0 +1,27 @@
+import fs from 'fs-extra';
+import crypto from 'crypto';
+
+export const checksum = {
+  async calculate(filePath) {
+    const content = await fs.readFile(filePath);
+    return crypto.createHash('md5').update(content).digest('hex');
+  },
+
+  async verify(filePath, expectedHash) {
+    const actualHash = await this.calculate(filePath);
+    return actualHash === expectedHash;
+  },
+
+  async generateManifest(dir, files = []) {
+    const manifest = {};
+    
+    for (const file of files) {
+      const filePath = `${dir}/${file}`;
+      if (fs.existsSync(filePath)) {
+        manifest[file] = await this.calculate(filePath);
+      }
+    }
+    
+    return manifest;
+  }
+};

package/src/lib/config.js

@@ -0,0 +1,23 @@
+export const config = {
+  defaults: {
+    template: 'web-pwa',
+    assets: ['components', 'skills', 'engine'],
+    theme: 'cool-light'
+  },
+
+  projectTypes: {
+    'web-pwa': { framework: 'vanilla', features: ['pwa', 'offline'] },
+    'web-svelte': { framework: 'svelte', features: ['routing', 'stores'] },
+    'python-cli': { framework: 'python', features: ['cli', 'argparse'] },
+    'vba-excel': { framework: 'vba', features: ['excel', 'macros'] }
+  },
+
+  themes: {
+    'cool-light': { primary: '#3B82F6', secondary: '#10B981', accent: '#8B5CF6' },
+    'cool-dark': { primary: '#60A5FA', secondary: '#34D399', accent: '#A78BFA' },
+    'warm-light': { primary: '#F59E0B', secondary: '#EF4444', accent: '#8B5CF6' },
+    'warm-dark': { primary: '#FBBF24', secondary: '#F87171', accent: '#A78BFA' },
+    'neutral-light': { primary: '#6B7280', secondary: '#374151', accent: '#111827' },
+    'neutral-dark': { primary: '#9CA3AF', secondary: '#D1D5DB', accent: '#F9FAFB' }
+  }
+};

package/src/lib/manifest.js

@@ -0,0 +1,43 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export const manifest = {
+  async init(projectDir, data) {
+    const manifestPath = path.join(projectDir, 'g360-manifest.json');
+    const manifest = {
+      name: data.name,
+      template: data.template,
+      version: data.version,
+      createdAt: new Date().toISOString(),
+      assets: []
+    };
+    await fs.writeJson(manifestPath, manifest, { spaces: 2 });
+    return manifest;
+  },
+
+  async load(projectDir) {
+    const manifestPath = path.join(projectDir, 'g360-manifest.json');
+    if (fs.existsSync(manifestPath)) {
+      return fs.readJson(manifestPath);
+    }
+    return null;
+  },
+
+  async addAsset(projectDir, asset) {
+    const data = await this.load(projectDir);
+    if (data) {
+      data.assets.push({
+        ...asset,
+        addedAt: new Date().toISOString()
+      });
+      await fs.writeJson(path.join(projectDir, 'g360-manifest.json'), data, { spaces: 2 });
+    }
+  },
+
+  async remove(projectDir) {
+    const manifestPath = path.join(projectDir, 'g360-manifest.json');
+    if (fs.existsSync(manifestPath)) {
+      await fs.remove(manifestPath);
+    }
+  }
+};

package/src/lib/offline.js

@@ -0,0 +1,33 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export const offline = {
+  cache: new Map(),
+  cacheDir: '.g360-cache',
+
+  async isAvailable() {
+    return true;
+  },
+
+  async getCached(asset) {
+    return this.cache.get(asset);
+  },
+
+  async setCache(asset, data) {
+    this.cache.set(asset, data);
+  },
+
+  async loadFromCache(asset) {
+    const cachePath = path.join(this.cacheDir, `${asset}.json`);
+    if (fs.existsSync(cachePath)) {
+      return fs.readJson(cachePath);
+    }
+    return null;
+  },
+
+  async saveToCache(asset, data) {
+    const cachePath = path.join(this.cacheDir, `${asset}.json`);
+    await fs.ensureDir(this.cacheDir);
+    await fs.writeJson(cachePath, data);
+  }
+};