@nboard-dev/octus 0.3.0

package/src/commands/init.js

@@ -0,0 +1,311 @@
+import { Command } from 'commander';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, resolve, basename } from 'path';
+import { execa } from 'execa';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import YAML from 'yaml';
+import { config } from '../lib/config.js';
+import { api } from '../lib/api.js';
+import { approvedProfiles } from '../lib/config.js';
+import ui from '../lib/ui.js';
+import { createHash } from 'crypto';
+import { scanRepository } from '../lib/octus-contract.js';
+import { generateProfileWithAi } from '../lib/profile-generator.js';
+
+export const initCommand = new Command('init')
+  .description('Initialize and register a repository with Octus')
+  .argument('[path]', 'Local repo path or Git URL to clone', '.')
+  .option('-d, --clone-dir <dir>', 'Target directory for cloning Git URLs')
+  .option('--run-setup', 'Immediately run setup after init')
+  .option('--setup-profile <profile>', 'Profile to use for setup', 'auto')
+  .option('--setup-ignore-repo-profile', 'Ignore repo-local profile during setup')
+  .option('--setup-timeout <seconds>', 'Per-step timeout for setup', '300')
+  .action(async (pathArg, options) => {
+    // Check login
+    if (!config.isLoggedIn()) {
+      ui.error('Not logged in. Run `octus login` first.');
+      process.exit(1);
+    }
+
+    let repoPath;
+    const isGitUrl = pathArg.startsWith('http') || pathArg.startsWith('git@');
+
+    ui.header('Octus Init');
+
+    // ─────────────────────────────────────────────────────────────
+    // Handle Git URL cloning
+    // ─────────────────────────────────────────────────────────────
+
+    if (isGitUrl) {
+      const cloneDir = options.cloneDir || basename(pathArg.replace(/\.git$/, ''));
+      repoPath = resolve(cloneDir);
+
+      if (existsSync(repoPath)) {
+        ui.error(`Directory ${cloneDir} already exists`);
+        process.exit(1);
+      }
+
+      const spin = ui.spinner(`Cloning ${pathArg}...`).start();
+      try {
+        await execa('git', ['clone', pathArg, cloneDir]);
+        spin.succeed(`Cloned to ${cloneDir}`);
+      } catch (err) {
+        spin.fail(`Clone failed: ${err.message}`);
+        process.exit(1);
+      }
+    } else {
+      repoPath = resolve(pathArg);
+    }
+
+    // Verify it's a git repo
+    if (!existsSync(join(repoPath, '.git'))) {
+      ui.error(`${repoPath} is not a git repository`);
+      process.exit(1);
+    }
+
+    ui.info(`Repository: ${repoPath}`);
+
+    // ─────────────────────────────────────────────────────────────
+    // Analyze repository
+    // ─────────────────────────────────────────────────────────────
+
+    const spin = ui.spinner('Analyzing repository...').start();
+
+    // Get git remote
+    let gitRemoteUrl = null;
+    try {
+      const { stdout } = await execa('git', ['remote', 'get-url', 'origin'], { cwd: repoPath });
+      gitRemoteUrl = stdout.trim();
+    } catch {
+      // No remote, that's ok
+    }
+
+    // Detect project type
+    const projectType = detectProjectType(repoPath);
+    spin.text = `Detected: ${projectType}`;
+
+    // Scan repo structure
+    const scanResult = scanRepository(repoPath);
+    const repoData = {
+      name: basename(repoPath),
+      local_path: repoPath,
+      git_url: gitRemoteUrl,
+      default_branch: 'main',
+      project_type: projectType,
+      metadata: scanResult.metadata,
+      has_readme: scanResult.has_readme,
+      has_dockerfile: scanResult.has_dockerfile,
+      has_docker_compose: scanResult.has_docker_compose
+    };
+
+    spin.succeed('Repository analyzed');
+
+    // ─────────────────────────────────────────────────────────────
+    // Ensure .octusignore
+    // ─────────────────────────────────────────────────────────────
+
+    const octusignorePath = join(repoPath, '.octusignore');
+    if (!existsSync(octusignorePath)) {
+      writeFileSync(octusignorePath, getDefaultOctusignore());
+      ui.info('Created .octusignore');
+    }
+
+    // ─────────────────────────────────────────────────────────────
+    // Generate onboarding profile
+    // ─────────────────────────────────────────────────────────────
+
+    const profileDir = join(repoPath, '.octus');
+    const profilePath = join(profileDir, 'profile.json');
+
+    if (!existsSync(profileDir)) {
+      mkdirSync(profileDir, { recursive: true });
+    }
+
+    let profile;
+    if (existsSync(profilePath)) {
+      ui.info('Using existing profile');
+      profile = JSON.parse(readFileSync(profilePath, 'utf-8'));
+    } else {
+      const genSpin = ui.spinner('Generating onboarding profile...').start();
+      const generation = await generateProfileWithAi(repoPath);
+      profile = generation.profile;
+      if (generation.usedAi) {
+        genSpin.succeed('AI onboarding profile generated');
+      } else {
+        genSpin.succeed('Rule-based onboarding profile generated');
+        if (generation.fallbackReason) {
+          ui.warning(generation.fallbackReason);
+        }
+      }
+
+      // Show profile for review
+      ui.divider();
+      ui.header('Generated Onboarding Steps');
+      profile.steps.forEach((step, i) => {
+        console.log(`  ${chalk.cyan(i + 1)}. ${step.name || step.title}`);
+        console.log(`     ${chalk.dim(step.command || step.description || '')}`);
+      });
+      ui.divider();
+
+      // Ask for approval
+      const { approved } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'approved',
+          message: 'Approve this onboarding profile?',
+          default: true
+        }
+      ]);
+
+      if (!approved) {
+        ui.warning('Profile not approved. Edit .octus/profile.json and run init again.');
+        writeFileSync(profilePath, JSON.stringify(profile, null, 2));
+        process.exit(0);
+      }
+
+      // Save profile
+      writeFileSync(profilePath, JSON.stringify(profile, null, 2));
+      
+      // Record approval
+      const profileHash = createHash('sha256')
+        .update(JSON.stringify(profile))
+        .digest('hex');
+      approvedProfiles.add(profilePath, profileHash, profile.profile_name || profile.name || 'generated');
+      
+      ui.success('Profile approved and saved');
+    }
+
+    // ─────────────────────────────────────────────────────────────
+    // Register with backend
+    // ─────────────────────────────────────────────────────────────
+
+    const regSpin = ui.spinner('Registering repository...').start();
+    
+    try {
+      const repo = await api.registerRepository(repoData);
+      regSpin.text = 'Resolving profile...';
+
+      const resolved = await api.resolveProfile(repo.id, gitRemoteUrl);
+      regSpin.text = 'Getting signed init file...';
+
+      const initFile = await api.createInitFile(repo.id, resolved.profile_key || 'auto');
+      
+      // Write .octus.yaml
+      const octusYamlPath = join(repoPath, '.octus.yaml');
+      writeFileSync(
+        octusYamlPath,
+        typeof initFile.content === 'string' ? initFile.content : YAML.stringify(initFile)
+      );
+      
+      regSpin.succeed('Repository registered');
+
+      // Update .gitignore
+      updateGitignore(repoPath);
+
+    } catch (err) {
+      regSpin.fail(`Registration failed: ${err.message}`);
+      process.exit(1);
+    }
+
+    // ─────────────────────────────────────────────────────────────
+    // Success
+    // ─────────────────────────────────────────────────────────────
+
+    ui.divider();
+    ui.successPanel('Repository Initialized', `
+${chalk.bold('Created files:')}
+  • .octus/profile.json
+  • .octus.yaml
+  • .octusignore
+
+${chalk.bold('Next steps:')}
+  ${chalk.cyan('octus setup')}     Run onboarding
+  ${chalk.cyan('octus doctor')}    Check status
+`);
+
+    // Run setup if requested
+    if (options.runSetup) {
+      ui.divider();
+      ui.info('Running setup...');
+      // Import and run setup command
+      const { runSetup } = await import('./setup.js');
+      await runSetup(repoPath, {
+        profile: options.setupProfile,
+        ignoreRepoProfile: options.setupIgnoreRepoProfile,
+        timeout: parseInt(options.setupTimeout, 10)
+      });
+    }
+  });
+
+/**
+ * Detect project type based on files
+ */
+function detectProjectType(repoPath) {
+  if (existsSync(join(repoPath, 'package.json'))) return 'node';
+  if (existsSync(join(repoPath, 'pyproject.toml'))) return 'python';
+  if (existsSync(join(repoPath, 'requirements.txt'))) return 'python';
+  if (existsSync(join(repoPath, 'Cargo.toml'))) return 'rust';
+  if (existsSync(join(repoPath, 'go.mod'))) return 'go';
+  if (existsSync(join(repoPath, 'pom.xml'))) return 'java';
+  if (existsSync(join(repoPath, 'Gemfile'))) return 'ruby';
+  return 'generic';
+}
+
+/**
+ * Default .octusignore content
+ */
+function getDefaultOctusignore() {
+  return `# Octus ignore file - files to exclude from AI context
+# Syntax is similar to .gitignore
+
+# Secrets and credentials
+.env
+.env.*
+*.pem
+*.key
+secrets/
+credentials/
+
+# Dependencies
+node_modules/
+.venv/
+venv/
+__pycache__/
+
+# Build outputs
+dist/
+build/
+*.pyc
+*.o
+*.so
+
+# IDE
+.idea/
+.vscode/
+*.swp
+
+# OS
+.DS_Store
+Thumbs.db
+`;
+}
+
+/**
+ * Update .gitignore to include Octus files
+ */
+function updateGitignore(repoPath) {
+  const gitignorePath = join(repoPath, '.gitignore');
+  const octusEntries = '\n# Octus\n.octus/profile.json\n.octus.yaml\n';
+
+  if (existsSync(gitignorePath)) {
+    const content = readFileSync(gitignorePath, 'utf-8');
+    if (!content.includes('.octus/profile.json') || !content.includes('.octus.yaml')) {
+      writeFileSync(gitignorePath, content + octusEntries);
+    }
+  } else {
+    writeFileSync(gitignorePath, octusEntries);
+  }
+}
+
+export default initCommand;

package/src/commands/login.js

@@ -0,0 +1,60 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { config } from '../lib/config.js';
+import { api } from '../lib/api.js';
+import ui from '../lib/ui.js';
+
+export const loginCommand = new Command('login')
+  .description('Authenticate with Octus Backend and save API key')
+  .option('-u, --backend-url <url>', 'Backend API URL', 'http://localhost:8000')
+  .option('-k, --api-key <key>', 'API key (will prompt if not provided)')
+  .action(async (options) => {
+    let { backendUrl, apiKey } = options;
+    const previousConfig = config.get();
+
+    // Prompt for API key if not provided
+    if (!apiKey) {
+      const answers = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'apiKey',
+          message: 'Enter your Octus API key:',
+          mask: '•',
+          validate: (input) => input.length > 0 || 'API key is required'
+        }
+      ]);
+      apiKey = answers.apiKey;
+    }
+
+    const spin = ui.spinner('Authenticating...').start();
+
+    try {
+      // Temporarily set config to test the credentials
+      config.set({ apiKey, backendUrl });
+
+      // Validate credentials
+      const user = await api.getMe();
+      spin.text = 'Fetching organization...';
+      
+      const org = await api.getMyOrganization();
+      
+      spin.succeed('Authenticated successfully!');
+
+      ui.divider();
+      ui.success(`Logged in as ${user.email || user.name || 'user'}`);
+      ui.keyValue([
+        ['Organization', org.name || 'N/A'],
+        ['Backend', backendUrl],
+        ['Config saved', config.getConfigPath()]
+      ]);
+      ui.divider();
+
+    } catch (err) {
+      spin.fail('Authentication failed');
+      config.set({ apiKey: previousConfig.apiKey, backendUrl: previousConfig.backendUrl });
+      ui.error(err.message);
+      process.exit(1);
+    }
+  });
+
+export default loginCommand;

package/src/commands/logout.js

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+import { config } from '../lib/config.js';
+import ui from '../lib/ui.js';
+
+export const logoutCommand = new Command('logout')
+  .description('Clear stored credentials')
+  .action(async () => {
+    const spin = ui.spinner('Clearing credentials...').start();
+    
+    try {
+      config.clear();
+      spin.succeed('Logged out successfully');
+      ui.info('All local Octus data has been cleared');
+    } catch (err) {
+      spin.fail('Failed to clear credentials');
+      ui.error(err.message);
+      process.exit(1);
+    }
+  });
+
+export default logoutCommand;

package/src/commands/ping.js

@@ -0,0 +1,72 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { config } from '../lib/config.js';
+import { api } from '../lib/api.js';
+import ui from '../lib/ui.js';
+
+export const pingCommand = new Command('ping')
+  .description('Check connectivity and authentication with Octus Backend')
+  .action(async () => {
+    ui.header('Octus Connection Check');
+    
+    const { backendUrl, apiKey } = config.get();
+    const results = [];
+
+    // Check 1: Backend URL configured
+    results.push(['Backend URL', backendUrl || 'Not configured', !!backendUrl]);
+
+    // Check 2: API key present
+    results.push(['API Key', apiKey ? ui.maskSecret(apiKey) : 'Not set', !!apiKey]);
+
+    // Check 3: Health endpoint
+    let healthOk = false;
+    try {
+      const health = await api.healthCheck();
+      healthOk = health.ok;
+      results.push(['Backend Health', healthOk ? 'Healthy' : 'Unhealthy', healthOk]);
+    } catch (err) {
+      results.push(['Backend Health', `Error: ${err.message}`, false]);
+    }
+
+    // Check 4: Authentication (only if health passed)
+    if (healthOk && apiKey) {
+      try {
+        const user = await api.getMe();
+        results.push(['Authentication', `✓ ${user.email || user.name || 'Authenticated'}`, true]);
+        
+        try {
+          const org = await api.getMyOrganization();
+          results.push(['Organization', org.name || 'N/A', true]);
+        } catch {
+          results.push(['Organization', 'Could not fetch', false]);
+        }
+      } catch (err) {
+        results.push(['Authentication', `Failed: ${err.message}`, false]);
+      }
+    } else if (!apiKey) {
+      results.push(['Authentication', 'Skipped (no API key)', false]);
+    }
+
+    // Display results
+    ui.divider();
+    ui.table(
+      ['Check', 'Status', 'Result'],
+      results.map(([check, status, ok]) => [
+        check,
+        status,
+        ok ? chalk.green('✓ Pass') : chalk.red('✗ Fail')
+      ])
+    );
+
+    // Summary
+    ui.divider();
+    const allPassed = results.every(([, , ok]) => ok);
+    if (allPassed) {
+      ui.success('All checks passed! Octus is ready to use.');
+    } else {
+      ui.warning('Some checks failed. Run `octus login` to configure.');
+      process.exit(1);
+    }
+  });
+
+export default pingCommand;