ppcos 0.3.0

package/lib/commands/init.js

@@ -0,0 +1,229 @@
+/**
+ * init command - Create a new client workspace
+ *
+ * Usage: ppcos init <client-name> [--skip-config]
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { validateClientName } from '../utils/validation.js';
+import { calculateChecksum } from '../utils/checksum.js';
+import { createManifest, writeManifest, manifestExists, getManagedType } from '../utils/manifest.js';
+import { getAllFiles, copyFileWithDirs, ensureDir, fileExists } from '../utils/fs-helpers.js';
+import { fetchSkills } from '../utils/skills-fetcher.js';
+import { requireAuth } from '../utils/auth.js';
+import logger from '../utils/logger.js';
+import ora from 'ora';
+
+// Get package root directory
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PACKAGE_ROOT = join(__dirname, '..', '..');
+
+/**
+ * Get package version from package.json
+ * @returns {string}
+ */
+function getPackageVersion() {
+  const pkgPath = join(PACKAGE_ROOT, 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  return pkg.version;
+}
+
+/**
+ * Get path to .claude-base template directory
+ * @returns {string}
+ */
+function getBaseTemplatePath() {
+  return join(PACKAGE_ROOT, '.claude-base');
+}
+
+/**
+ * Get clients directory path
+ * @returns {string}
+ */
+function getClientsDir() {
+  return join(process.cwd(), 'clients');
+}
+
+/**
+ * Add client to main-config.json
+ * @param {string} clientName
+ */
+async function addToMainConfig(clientName) {
+  const configPath = join(process.cwd(), 'main-config.json');
+
+  let config;
+  if (existsSync(configPath)) {
+    const content = await readFile(configPath, 'utf8');
+    config = JSON.parse(content);
+
+    // Check if client already exists
+    const exists = config.clients.some(c => c.name === clientName);
+    if (exists) {
+      logger.debug(`Client "${clientName}" already in main-config.json`);
+      return;
+    }
+  } else {
+    // Create new config
+    config = {
+      version: '1.0',
+      clients: []
+    };
+  }
+
+  // Add the new client
+  config.clients.push({
+    name: clientName,
+    enabled: true
+  });
+
+  await writeFile(configPath, JSON.stringify(config, null, 2) + '\n');
+  logger.debug(`Added "${clientName}" to main-config.json`);
+}
+
+/**
+ * Create main-config.json template
+ */
+async function createConfigTemplate() {
+  const configPath = join(process.cwd(), 'main-config.json');
+
+  if (existsSync(configPath)) {
+    logger.error('main-config.json already exists.');
+    process.exitCode = 1;
+    return;
+  }
+
+  const template = {
+    version: '1.0',
+    clients: [
+      { name: 'client-example', enabled: true }
+    ]
+  };
+
+  await writeFile(configPath, JSON.stringify(template, null, 2) + '\n');
+
+  logger.success('Created main-config.json');
+  console.log('');
+  console.log('Next steps:');
+  console.log('  1. Edit main-config.json with your client names');
+  console.log('  2. Run: ppcos init-all');
+}
+
+/**
+ * Main init command handler
+ * @param {string} [clientName] - Name of the client (optional)
+ * @param {object} options - Command options
+ * @param {boolean} options.skipConfig - Skip adding to main-config.json
+ */
+export default async function init(clientName, options = {}) {
+  // No client name = create config template
+  if (!clientName) {
+    await createConfigTemplate();
+    return;
+  }
+
+  // 1. Validate client name
+  const validation = validateClientName(clientName);
+  if (!validation.valid) {
+    logger.error(`Invalid client name "${clientName}". ${validation.error}`);
+    logger.info('Use lowercase letters, numbers, and hyphens only. Must start with a letter.');
+    process.exitCode = 1;
+    return;
+  }
+
+  // 2. Check for existing folder
+  const clientsDir = getClientsDir();
+  const clientDir = join(clientsDir, clientName);
+
+  if (existsSync(clientDir)) {
+    if (manifestExists(clientDir)) {
+      logger.error(`Folder "clients/${clientName}" already exists with a managed workspace.`);
+      logger.info("Use 'ppcos update' to update existing clients.");
+    } else {
+      logger.error(`Folder "clients/${clientName}" already exists.`);
+      logger.info('Remove it manually or choose a different name.');
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  // 3. Fetch skills from API (with local fallback for dev/testing)
+  const spinner = ora('Fetching skills from API...').start();
+  let usedLocalFallback = false;
+
+  try {
+    await fetchSkills(clientDir);
+    spinner.succeed('Skills downloaded');
+  } catch (error) {
+    spinner.fail('Failed to fetch skills');
+
+    // Fallback to local .claude-base for development/testing
+    const basePath = getBaseTemplatePath();
+    if (existsSync(basePath)) {
+      logger.warn('Using local .claude-base (dev/testing mode)');
+      const baseFiles = await getAllFiles(basePath);
+
+      for (const relativePath of baseFiles) {
+        const srcPath = join(basePath, relativePath);
+        const destPath = join(clientDir, relativePath);
+        await copyFileWithDirs(srcPath, destPath);
+      }
+      usedLocalFallback = true;
+    } else {
+      logger.error(error.message);
+      logger.error('No local fallback available. Run: ppcos login');
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  // 4. Calculate checksums for all downloaded files
+  const version = getPackageVersion();
+  const baseFiles = await getAllFiles(clientDir);
+  const managedFiles = {};
+
+  const checksumSpinner = ora(`Calculating checksums for ${baseFiles.length} files...`).start();
+
+  for (const relativePath of baseFiles) {
+    const filePath = join(clientDir, relativePath);
+    const checksum = await calculateChecksum(filePath);
+    const managedType = getManagedType(relativePath);
+    managedFiles[relativePath] = {
+      checksum,
+      version,
+      managedType
+    };
+  }
+
+  checksumSpinner.succeed('Checksums calculated');
+
+  // 5. Generate and write .managed.json
+  const manifest = createManifest(version, managedFiles);
+  await writeManifest(clientDir, manifest);
+
+  // 6. Update main-config.json (unless --skip-config)
+  if (!options.skipConfig) {
+    try {
+      await addToMainConfig(clientName);
+    } catch (err) {
+      logger.warn(`Could not update main-config.json: ${err.message}`);
+    }
+  }
+
+  // 7. Display success message
+  console.log('');
+  logger.success(`Client "${clientName}" initialized (v${version})`);
+  console.log('');
+  console.log(`Location: clients/${clientName}/`);
+  console.log('');
+  console.log('Next steps:');
+  console.log(`  1. cd clients/${clientName}`);
+  console.log('  2. Customize CLAUDE.md for this client');
+  console.log('  3. Run /ppcos <website> to gather brand context');
+}
+
+// Export helpers for testing
+export { getPackageVersion, getBaseTemplatePath, getClientsDir, addToMainConfig };

package/lib/commands/login.js

@@ -0,0 +1,85 @@
+import readline from 'readline';
+import logger from '../utils/logger.js';
+import { writeAuth } from '../utils/auth.js';
+import { sendVerificationCode, verifyCode } from '../utils/api-client.js';
+import ora from 'ora';
+
+/**
+ * Interactive login flow with email + OTP
+ */
+export async function login() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  try {
+    // Step 1: Get email
+    const email = await new Promise((resolve) => {
+      rl.question('Email: ', resolve);
+    });
+
+    if (!email || !email.includes('@')) {
+      logger.error('Invalid email address');
+      rl.close();
+      return;
+    }
+
+    // Step 2: Send code
+    // Close readline before spinner to avoid terminal conflicts
+    rl.close();
+
+    const spinner = ora('Sending verification code...').start();
+
+    let sendResult;
+    try {
+      sendResult = await sendVerificationCode(email.trim());
+      spinner.succeed('Code sent to your email');
+    } catch (error) {
+      spinner.fail('Failed to send code');
+      logger.error(error.message);
+      return;
+    }
+
+    // Step 3: Get code
+    // Recreate readline after spinner
+    const rl2 = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const code = await new Promise((resolve) => {
+      rl2.question('Enter verification code: ', resolve);
+    });
+    rl2.close();
+
+    if (!code || code.length !== 6) {
+      logger.error('Invalid code format');
+      return;
+    }
+
+    // Step 4: Verify code
+    const verifySpinner = ora('Verifying...').start();
+
+    try {
+      const result = await verifyCode(email.trim(), code.trim(), sendResult.token);
+      verifySpinner.succeed('Verified');
+
+      // Step 5: Store session
+      writeAuth({
+        email: result.email,
+        sessionToken: result.sessionToken,
+        expiresAt: result.expiresAt
+      });
+
+      logger.success(`✓ Logged in as ${result.email}`);
+      logger.info(`Session expires: ${new Date(result.expiresAt).toLocaleString()}`);
+    } catch (error) {
+      verifySpinner.fail('Verification failed');
+      logger.error(error.message);
+    }
+  } catch (error) {
+    logger.error(`Login failed: ${error.message}`);
+    rl.close();
+  }
+}

package/lib/commands/logout.js

@@ -0,0 +1,17 @@
+import logger from '../utils/logger.js';
+import { clearAuth, readAuth } from '../utils/auth.js';
+
+/**
+ * Clear authentication session
+ */
+export async function logout() {
+  const auth = readAuth();
+
+  if (!auth) {
+    logger.info('Not logged in');
+    return;
+  }
+
+  clearAuth();
+  logger.success(`✓ Logged out ${auth.email}`);
+}

package/lib/commands/status.js

@@ -0,0 +1,289 @@
+/**
+ * status command - Show version and modification status
+ *
+ * Usage: ppcos status [--client <name>]
+ */
+
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  readManifest,
+  manifestExists,
+  detectModifications
+} from '../utils/manifest.js';
+import { getAllFiles } from '../utils/fs-helpers.js';
+import { readAuth } from '../utils/auth.js';
+import logger from '../utils/logger.js';
+import chalk from 'chalk';
+
+// Get package root directory
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PACKAGE_ROOT = join(__dirname, '..', '..');
+
+/**
+ * Get package version from package.json
+ * @returns {string}
+ */
+function getPackageVersion() {
+  const pkgPath = join(PACKAGE_ROOT, 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  return pkg.version;
+}
+
+/**
+ * Get path to .claude-base template directory
+ * @returns {string}
+ */
+function getBaseTemplatePath() {
+  return join(PACKAGE_ROOT, '.claude-base');
+}
+
+/**
+ * Get clients directory path
+ * @returns {string}
+ */
+function getClientsDir() {
+  return join(process.cwd(), 'clients');
+}
+
+/**
+ * Find all client directories with .managed.json
+ * @returns {string[]} Array of client names
+ */
+function discoverClients() {
+  const clientsDir = getClientsDir();
+
+  if (!existsSync(clientsDir)) {
+    return [];
+  }
+
+  const entries = readdirSync(clientsDir, { withFileTypes: true });
+  const clients = [];
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const clientDir = join(clientsDir, entry.name);
+      if (manifestExists(clientDir)) {
+        clients.push(entry.name);
+      }
+    }
+  }
+
+  return clients;
+}
+
+/**
+ * Find custom skills in a client directory
+ * Custom skills are skill directories not tracked in managedFiles
+ * @param {string} clientDir - Path to client directory
+ * @param {object} manifest - The manifest object
+ * @returns {string[]} Array of custom skill names
+ */
+function findCustomSkills(clientDir, manifest) {
+  const skillsDir = join(clientDir, '.claude', 'skills');
+
+  if (!existsSync(skillsDir)) {
+    return [];
+  }
+
+  const entries = readdirSync(skillsDir, { withFileTypes: true });
+  const customSkills = [];
+
+  // Get managed skill directories from manifest
+  const managedSkillDirs = new Set();
+  for (const path of Object.keys(manifest.managedFiles)) {
+    if (path.startsWith('.claude/skills/')) {
+      const parts = path.split('/');
+      if (parts.length >= 3) {
+        managedSkillDirs.add(parts[2]);
+      }
+    }
+  }
+
+  for (const entry of entries) {
+    if (entry.isDirectory() && !managedSkillDirs.has(entry.name)) {
+      customSkills.push(entry.name);
+    }
+  }
+
+  return customSkills;
+}
+
+/**
+ * Get status for a single client
+ * @param {string} clientName - Client name
+ * @returns {Promise<object>} Client status object
+ */
+async function getClientStatus(clientName) {
+  const clientsDir = getClientsDir();
+  const clientDir = join(clientsDir, clientName);
+  const basePath = getBaseTemplatePath();
+  const packageVersion = getPackageVersion();
+
+  // Read manifest
+  const manifest = await readManifest(clientDir);
+  const currentVersion = manifest.baseVersion;
+
+  // Get base template files for detecting modifications
+  const baseFiles = await getAllFiles(basePath);
+
+  // Detect modifications
+  const mods = await detectModifications(clientDir, manifest, baseFiles);
+
+  // Find custom skills
+  const customSkills = findCustomSkills(clientDir, manifest);
+
+  // Find config files
+  const configFiles = Object.entries(manifest.managedFiles)
+    .filter(([path, info]) => (info.managedType || 'update') === 'config')
+    .map(([path]) => path);
+
+  // Check if update available
+  const updateAvailable = currentVersion !== packageVersion;
+
+  return {
+    name: clientName,
+    version: currentVersion,
+    packageVersion,
+    updateAvailable,
+    managedCount: Object.keys(manifest.managedFiles).length,
+    modifiedFiles: mods.modified,
+    missingFiles: mods.missing,
+    customSkills,
+    conflicts: manifest.conflicts || [],
+    configFiles
+  };
+}
+
+/**
+ * Main status command handler
+ * @param {object} options - Command options
+ * @param {string} [options.client] - Show only this client
+ */
+export default async function status(options = {}) {
+  const packageVersion = getPackageVersion();
+  const basePath = getBaseTemplatePath();
+
+  // Check base template exists
+  if (!existsSync(basePath)) {
+    logger.error('Template directory not found. Package may be corrupted.');
+    process.exitCode = 1;
+    return;
+  }
+
+  // Discover clients
+  let clients = discoverClients();
+
+  if (clients.length === 0) {
+    logger.info('No clients found.');
+    console.log('');
+    console.log('To create a client:');
+    console.log('  ppcos init <client-name>');
+    console.log('');
+    console.log('Or create main-config.json and run:');
+    console.log('  ppcos init-all');
+    return;
+  }
+
+  // Filter to specific client if requested
+  if (options.client) {
+    if (!clients.includes(options.client)) {
+      logger.error(`Client "${options.client}" not found.`);
+      process.exitCode = 1;
+      return;
+    }
+    clients = [options.client];
+  }
+
+  // Print header
+  console.log('ppcos-hub/');
+  console.log('');
+
+  // Process each client
+  for (const clientName of clients) {
+    try {
+      const clientStatus = await getClientStatus(clientName);
+
+      // Client name
+      console.log(`  ${clientStatus.name}`);
+
+      // Version line
+      if (clientStatus.updateAvailable) {
+        console.log(`    Version: ${clientStatus.version} → ${clientStatus.packageVersion} available`);
+      } else {
+        console.log(`    Version: ${clientStatus.version} (up to date)`);
+      }
+
+      // Managed files count
+      console.log(`    Managed: ${clientStatus.managedCount} files`);
+
+      // Modified files
+      console.log(`    Modified: ${clientStatus.modifiedFiles.length} files`);
+      for (const file of clientStatus.modifiedFiles) {
+        console.log(`      - ${file}`);
+      }
+
+      // Custom skills
+      const skillCount = clientStatus.customSkills.length;
+      if (skillCount === 0) {
+        console.log('    Custom: 0 skills');
+      } else if (skillCount === 1) {
+        console.log(`    Custom: 1 skill (${clientStatus.customSkills[0]})`);
+      } else {
+        console.log(`    Custom: ${skillCount} skills (${clientStatus.customSkills.join(', ')})`);
+      }
+
+      // Config files
+      const configCount = clientStatus.configFiles?.length || 0;
+      if (configCount > 0) {
+        console.log(`    Config: ${configCount} files (never updated)`);
+        for (const file of clientStatus.configFiles) {
+          console.log(`      - ${file}`);
+        }
+      }
+
+      // Conflicts
+      console.log(`    Conflicts: ${clientStatus.conflicts.length}`);
+
+      console.log('');
+    } catch (err) {
+      logger.error(`Failed to get status for ${clientName}: ${err.message}`);
+      console.log('');
+    }
+  }
+
+  // Auth status
+  const auth = readAuth();
+  if (auth?.sessionToken) {
+    const expiresAt = new Date(auth.expiresAt);
+    const now = new Date();
+    const isExpired = expiresAt < now;
+
+    if (isExpired) {
+      console.log(`Auth: ${chalk.red('expired')} (${auth.email})`);
+      console.log(`  Run: ${chalk.cyan('ppcos login')}`);
+    } else {
+      const hoursLeft = Math.floor((expiresAt - now) / (1000 * 60 * 60));
+      console.log(`Auth: ${chalk.green('active')} (${auth.email})`);
+      console.log(`  Expires in ${hoursLeft}h`);
+    }
+  } else {
+    console.log(`Auth: ${chalk.red('not logged in')} - run ${chalk.cyan('ppcos login')}`);
+  }
+
+  // Package version footer
+  console.log('');
+  console.log(`Package version: ${packageVersion}`);
+}
+
+// Export helpers for testing
+export {
+  getPackageVersion,
+  getBaseTemplatePath,
+  getClientsDir,
+  discoverClients,
+  findCustomSkills,
+  getClientStatus
+};