evizi-cli 1.0.0

package/bin/evizi.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { initCommand } from '../src/commands/init.js';
+import { upgradeCommand } from '../src/commands/upgrade.js';
+
+program
+  .name('evizi')
+  .description('Install and manage agent kits from evizi-kit')
+  .version('1.0.0');
+
+program
+  .command('init')
+  .description('Install agent kits into your project')
+  .option('--agent <kits>', 'Comma-separated kit names (e.g. claude,cursor,github)')
+  .option('--all', 'Install all available kits')
+  .option('--local <path>', 'Use local evizi-kit directory instead of npm')
+  .action(initCommand);
+
+program
+  .command('upgrade')
+  .description('Upgrade installed agent kits to latest version')
+  .option('--local <path>', 'Use local evizi-kit directory instead of npm')
+  .action(upgradeCommand);
+
+program.parse();

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "evizi-cli",
+  "version": "1.0.0",
+  "description": "Install and manage agent kits from evizi-kit",
+  "type": "module",
+  "bin": {
+    "evizi": "./bin/evizi.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "dependencies": {
+    "commander": "^12.0.0",
+    "inquirer": "^9.0.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "license": "MIT"
+}

package/src/commands/init.js

@@ -0,0 +1,127 @@
+import inquirer from 'inquirer';
+import { resolveKitSource } from '../lib/resolver.js';
+import {
+  listAvailableKits,
+  getSelectableKits,
+  resolveDependencies,
+  loadManifest,
+} from '../lib/manifest.js';
+import { loadIgnorePatterns } from '../lib/ignore.js';
+import { copyKit } from '../lib/copier.js';
+import { readLockfile, writeLockfile } from '../lib/lockfile.js';
+
+export async function initCommand(options) {
+  const targetDir = process.cwd();
+
+  // Check for existing lockfile
+  const existingLock = readLockfile(targetDir);
+  if (existingLock) {
+    const { proceed } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'proceed',
+        message: 'evizi kits are already installed. Overwrite?',
+        default: false,
+      },
+    ]);
+    if (!proceed) {
+      console.log('Aborted.');
+      return;
+    }
+  }
+
+  // Resolve kit source
+  console.log(
+    options.local
+      ? `Using local kits from: ${options.local}`
+      : 'Downloading evizi-kit from npm...',
+  );
+
+  const { kitsDir, cleanup } = resolveKitSource(options);
+
+  try {
+    const allKits = listAvailableKits(kitsDir);
+    const selectableKits = getSelectableKits(allKits);
+
+    // Determine which kits to install
+    let selectedNames;
+
+    if (options.all) {
+      selectedNames = selectableKits.map((k) => k.name);
+    } else if (options.agent) {
+      selectedNames = options.agent.split(',').map((s) => s.trim());
+
+      // Validate kit names
+      const validNames = new Set(selectableKits.map((k) => k.name));
+      for (const name of selectedNames) {
+        if (!validNames.has(name)) {
+          console.error(
+            `Unknown kit: "${name}". Available: ${[...validNames].join(', ')}`,
+          );
+          return;
+        }
+      }
+    } else {
+      // Interactive selection
+      const { kits } = await inquirer.prompt([
+        {
+          type: 'checkbox',
+          name: 'kits',
+          message: 'Which agent kits do you want to install?',
+          choices: selectableKits.map((k) => ({
+            name: `${k.displayName} — ${k.description}`,
+            value: k.name,
+            checked: false,
+          })),
+        },
+      ]);
+      selectedNames = kits;
+
+      if (selectedNames.length === 0) {
+        console.log('No kits selected. Aborted.');
+        return;
+      }
+    }
+
+    // Resolve dependencies
+    const resolvedNames = resolveDependencies(kitsDir, selectedNames);
+    const depOnly = resolvedNames.filter((n) => !selectedNames.includes(n));
+    if (depOnly.length > 0) {
+      console.log(`Auto-including dependencies: ${depOnly.join(', ')}`);
+    }
+
+    // Load ignore patterns
+    const ignorePatterns = loadIgnorePatterns(targetDir);
+
+    // Copy kits
+    const kitsData = {};
+    let totalFiles = 0;
+
+    for (const kitName of resolvedNames) {
+      const manifest = loadManifest(kitsDir, kitName);
+      const copiedFiles = copyKit(
+        kitsDir,
+        kitName,
+        manifest,
+        targetDir,
+        ignorePatterns,
+      );
+
+      kitsData[kitName] = {
+        version: manifest.version,
+        files: copiedFiles,
+      };
+
+      totalFiles += copiedFiles.length;
+      console.log(`  ✓ ${manifest.displayName} (${copiedFiles.length} files)`);
+    }
+
+    // Write lockfile
+    writeLockfile(targetDir, kitsData);
+
+    console.log(`\nInstalled ${resolvedNames.length} kits (${totalFiles} files).`);
+    console.log('Lock file written to .evizi-lock.json');
+  } finally {
+    cleanup();
+  }
+}

package/src/commands/upgrade.js

@@ -0,0 +1,101 @@
+import { unlinkSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveKitSource } from '../lib/resolver.js';
+import { loadManifest } from '../lib/manifest.js';
+import { loadIgnorePatterns } from '../lib/ignore.js';
+import { copyKit } from '../lib/copier.js';
+import { readLockfile, writeLockfile } from '../lib/lockfile.js';
+
+export async function upgradeCommand(options) {
+  const targetDir = process.cwd();
+
+  // Read existing lockfile
+  const lockfile = readLockfile(targetDir);
+  if (!lockfile) {
+    console.error('No .evizi-lock.json found. Run `evizi init` first.');
+    process.exit(1);
+  }
+
+  console.log(
+    options.local
+      ? `Using local kits from: ${options.local}`
+      : 'Downloading latest evizi-kit from npm...',
+  );
+
+  const { kitsDir, cleanup } = resolveKitSource(options);
+
+  try {
+    const ignorePatterns = loadIgnorePatterns(targetDir);
+    const kitsData = {};
+    let updatedCount = 0;
+    let skippedCount = 0;
+
+    for (const kitName of Object.keys(lockfile.kits)) {
+      const oldKit = lockfile.kits[kitName];
+      let manifest;
+
+      try {
+        manifest = loadManifest(kitsDir, kitName);
+      } catch {
+        console.log(`  ⚠ Kit "${kitName}" no longer exists in source, skipping.`);
+        skippedCount++;
+        continue;
+      }
+
+      if (manifest.version === oldKit.version) {
+        console.log(`  — ${manifest.displayName} v${manifest.version} (up to date)`);
+        kitsData[kitName] = oldKit;
+        skippedCount++;
+        continue;
+      }
+
+      // Process deletions from manifest
+      for (const delPath of manifest.deletions) {
+        const fullPath = join(targetDir, delPath);
+        if (existsSync(fullPath)) {
+          unlinkSync(fullPath);
+          console.log(`    Deleted: ${delPath}`);
+        }
+      }
+
+      // Remove orphaned files (in old lockfile but not in new copy)
+      const copiedFiles = copyKit(
+        kitsDir,
+        kitName,
+        manifest,
+        targetDir,
+        ignorePatterns,
+      );
+
+      const newFileSet = new Set(copiedFiles);
+      for (const oldFile of oldKit.files || []) {
+        if (!newFileSet.has(oldFile)) {
+          const fullPath = join(targetDir, oldFile);
+          if (existsSync(fullPath)) {
+            unlinkSync(fullPath);
+            console.log(`    Removed orphan: ${oldFile}`);
+          }
+        }
+      }
+
+      kitsData[kitName] = {
+        version: manifest.version,
+        files: copiedFiles,
+      };
+
+      updatedCount++;
+      console.log(
+        `  ✓ ${manifest.displayName} v${oldKit.version} → v${manifest.version} (${copiedFiles.length} files)`,
+      );
+    }
+
+    // Write updated lockfile
+    writeLockfile(targetDir, kitsData);
+
+    console.log(
+      `\nUpgrade complete: ${updatedCount} updated, ${skippedCount} up to date.`,
+    );
+  } finally {
+    cleanup();
+  }
+}

package/src/lib/copier.js

@@ -0,0 +1,53 @@
+import { readdirSync, copyFileSync, mkdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { isIgnored } from './ignore.js';
+
+/**
+ * Copy a kit's files into the target directory based on manifest file mappings.
+ * Returns array of relative paths of copied files.
+ */
+export function copyKit(kitsDir, kitName, manifest, targetDir, ignorePatterns) {
+  const copiedFiles = [];
+  const kitDir = join(kitsDir, kitName);
+
+  for (const mapping of manifest.files) {
+    const srcPath = join(kitDir, mapping.src);
+    const destPath = join(targetDir, mapping.dest);
+
+    const stat = statSync(srcPath, { throwIfNoEntry: false });
+    if (!stat) continue;
+
+    if (stat.isDirectory()) {
+      walkAndCopy(srcPath, destPath, mapping.dest, ignorePatterns, copiedFiles);
+    } else {
+      const relPath = mapping.dest;
+      if (isIgnored(relPath, ignorePatterns)) continue;
+
+      mkdirSync(join(targetDir, relPath, '..'), { recursive: true });
+      copyFileSync(srcPath, destPath);
+      copiedFiles.push(relPath);
+    }
+  }
+
+  return copiedFiles;
+}
+
+function walkAndCopy(srcDir, destDir, baseRelPath, ignorePatterns, copiedFiles) {
+  const entries = readdirSync(srcDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry.name);
+    const destPath = join(destDir, entry.name);
+    const relPath = join(baseRelPath, entry.name);
+
+    if (entry.isDirectory()) {
+      walkAndCopy(srcPath, destPath, relPath, ignorePatterns, copiedFiles);
+    } else {
+      if (isIgnored(relPath, ignorePatterns)) continue;
+
+      mkdirSync(destDir, { recursive: true });
+      copyFileSync(srcPath, destPath);
+      copiedFiles.push(relPath);
+    }
+  }
+}

package/src/lib/ignore.js

@@ -0,0 +1,48 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Load .evizi-ignore patterns from the target directory.
+ */
+export function loadIgnorePatterns(targetDir) {
+  const ignorePath = join(targetDir, '.evizi-ignore');
+  if (!existsSync(ignorePath)) return [];
+
+  const content = readFileSync(ignorePath, 'utf-8');
+  return content
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith('#'));
+}
+
+/**
+ * Check if a relative path matches any ignore pattern.
+ * Supports simple glob patterns: * and **
+ */
+export function isIgnored(relativePath, patterns) {
+  for (const pattern of patterns) {
+    if (matchPattern(relativePath, pattern)) return true;
+  }
+  return false;
+}
+
+function matchPattern(filePath, pattern) {
+  // Exact match
+  if (filePath === pattern) return true;
+
+  // Check if file is inside an ignored directory
+  if (filePath.startsWith(pattern.endsWith('/') ? pattern : pattern + '/')) {
+    return true;
+  }
+
+  // Convert glob pattern to regex
+  const regexStr = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*\*/g, '{{GLOBSTAR}}')
+    .replace(/\*/g, '[^/]*')
+    .replace(/\{\{GLOBSTAR\}\}/g, '.*')
+    .replace(/\?/g, '[^/]');
+
+  const regex = new RegExp(`^${regexStr}$`);
+  return regex.test(filePath);
+}

package/src/lib/lockfile.js

@@ -0,0 +1,33 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const LOCKFILE_NAME = '.evizi-lock.json';
+
+/**
+ * Read the lockfile from a target directory.
+ * Returns null if not found.
+ */
+export function readLockfile(targetDir) {
+  const lockPath = join(targetDir, LOCKFILE_NAME);
+  if (!existsSync(lockPath)) return null;
+
+  try {
+    return JSON.parse(readFileSync(lockPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write the lockfile to a target directory.
+ */
+export function writeLockfile(targetDir, kitsData) {
+  const lockPath = join(targetDir, LOCKFILE_NAME);
+  const lockContent = {
+    version: '1.0.0',
+    installedAt: new Date().toISOString(),
+    kits: kitsData,
+  };
+
+  writeFileSync(lockPath, JSON.stringify(lockContent, null, 2) + '\n');
+}

package/src/lib/manifest.js

@@ -0,0 +1,75 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Load a single kit's manifest.json.
+ */
+export function loadManifest(kitsDir, kitName) {
+  const manifestPath = join(kitsDir, kitName, 'manifest.json');
+  const raw = readFileSync(manifestPath, 'utf-8');
+  const manifest = JSON.parse(raw);
+
+  return {
+    name: manifest.name,
+    displayName: manifest.displayName || manifest.name,
+    version: manifest.version || '1.0.0',
+    description: manifest.description || '',
+    files: manifest.files || [],
+    dependencies: manifest.dependencies || [],
+    deletions: manifest.deletions || [],
+  };
+}
+
+/**
+ * List all available kits (reads subdirectories of kitsDir).
+ * Returns manifests for all kits, with `shared` last.
+ */
+export function listAvailableKits(kitsDir) {
+  const entries = readdirSync(kitsDir, { withFileTypes: true });
+  const kits = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    try {
+      const manifest = loadManifest(kitsDir, entry.name);
+      kits.push(manifest);
+    } catch {
+      // Skip directories without valid manifest
+    }
+  }
+
+  return kits;
+}
+
+/**
+ * Get user-selectable kits (excludes shared/dependency-only kits).
+ */
+export function getSelectableKits(kits) {
+  return kits.filter((k) => k.name !== 'shared');
+}
+
+/**
+ * Resolve dependencies for selected kit names.
+ * Returns ordered list with dependencies first.
+ */
+export function resolveDependencies(kitsDir, selectedNames) {
+  const resolved = new Set();
+  const result = [];
+
+  function resolve(name) {
+    if (resolved.has(name)) return;
+    resolved.add(name);
+
+    const manifest = loadManifest(kitsDir, name);
+    for (const dep of manifest.dependencies) {
+      resolve(dep);
+    }
+    result.push(name);
+  }
+
+  for (const name of selectedNames) {
+    resolve(name);
+  }
+
+  return result;
+}

package/src/lib/resolver.js

@@ -0,0 +1,52 @@
+import { execSync } from 'node:child_process';
+import { mkdtempSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+/**
+ * Resolve the path to the kits/ directory from evizi-kit.
+ * Supports local path (for dev) or npm registry (for production).
+ */
+export function resolveKitSource(options = {}) {
+  if (options.local) {
+    const kitsDir = join(options.local, 'kits');
+    if (!existsSync(kitsDir)) {
+      throw new Error(`Local kits directory not found: ${kitsDir}`);
+    }
+    return { kitsDir, cleanup: () => {} };
+  }
+
+  // Download from npm registry
+  const tmpDir = mkdtempSync(join(tmpdir(), 'evizi-'));
+
+  try {
+    execSync(`npm pack evizi-kit --pack-destination "${tmpDir}"`, {
+      stdio: 'pipe',
+      cwd: tmpDir,
+    });
+
+    execSync(`tar -xzf evizi-kit-*.tgz`, {
+      stdio: 'pipe',
+      cwd: tmpDir,
+    });
+
+    const kitsDir = join(tmpDir, 'package', 'kits');
+    if (!existsSync(kitsDir)) {
+      throw new Error('Downloaded evizi-kit package does not contain kits/ directory');
+    }
+
+    return {
+      kitsDir,
+      cleanup: () => {
+        try {
+          execSync(`rm -rf "${tmpDir}"`, { stdio: 'pipe' });
+        } catch {}
+      },
+    };
+  } catch (err) {
+    try {
+      execSync(`rm -rf "${tmpDir}"`, { stdio: 'pipe' });
+    } catch {}
+    throw new Error(`Failed to download evizi-kit from npm: ${err.message}`);
+  }
+}