@nboard-dev/octus 0.3.0

package/src/lib/profile-generator.js

@@ -0,0 +1,443 @@
+import { Anthropic } from '@anthropic-ai/sdk';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { extname, join, relative, resolve } from 'path';
+import { execa } from 'execa';
+import YAML from 'yaml';
+
+const BLOCKED_FILES = [
+  '.env', '.env.*', '*.env', '.env.local', '.env.production', '.env.staging',
+  'config/secrets.yml', 'config/secrets.yaml', 'config/credentials.yml', 'config/master.key',
+  '.aws/credentials', '.aws/config', '.ssh/id_rsa', '.ssh/id_ed25519', '.ssh/id_ecdsa',
+  '.ssh/known_hosts', '.ssh/authorized_keys', '*.pem', '*.key', '*.p12', '*.pfx', '*.jks',
+  '.bashrc', '.zshrc', '.bash_history', '.zsh_history', '.psql_history', '.mysql_history',
+  '.irb_history', '.netrc', '.pgpass', 'kubeconfig', '*.kubeconfig', '.kube/config',
+  'serviceAccount*.json', '*service-account*.json', 'terraform.tfvars', '*.tfvars', '.npmrc',
+  '.pypirc', '.dockerconfigjson', 'docker-compose.override.yml', 'Thumbs.db', '.DS_Store',
+  '.vault-token', '.terraformrc', '*.tfstate', '.sops.yaml', '.config/gcloud/*', '.azure/*',
+  'application_default_credentials.json',
+];
+
+const SECRET_PATTERNS = [
+  /(?:api[_-]?key|apikey)\s*[:=]\s*["']?[\w-]{20,}/giu,
+  /(?:secret[_-]?key|secret)\s*[:=]\s*["']?[\w-]{20,}/giu,
+  /(?:password|passwd|pwd)\s*[:=]\s*["']?.{8,}/giu,
+  /token\s*[:=]\s*["']?[\w-]{20,}/giu,
+  /AKIA[0-9A-Z]{16}/g,
+  /sk-[a-zA-Z0-9]{32,}/g,
+  /AIza[0-9A-Za-z\-_]{35}/g,
+  /ghp_[0-9a-zA-Z]{36}/g,
+  /-----BEGIN (RSA|EC|OPENSSH) PRIVATE KEY-----/g,
+];
+
+const CONTEXT_EXCLUDED_DIRS = new Set([
+  '.git', 'node_modules', '__pycache__', 'dist', 'build', '.next', '.venv', 'venv', 'coverage',
+]);
+
+const CONTEXT_ROOT_FILES = [
+  'README.md', 'package.json', 'requirements.txt', 'pyproject.toml', 'Dockerfile',
+  'docker-compose.yml', 'docker-compose.yaml', 'Makefile', '.env.example', '.env.sample',
+  '.nvmrc', '.python-version',
+];
+
+const LANGUAGE_SUFFIX_MAP = {
+  '.py': 'Python', '.js': 'JavaScript', '.jsx': 'JavaScript', '.ts': 'TypeScript',
+  '.tsx': 'TypeScript', '.go': 'Go', '.rs': 'Rust', '.java': 'Java', '.kt': 'Kotlin',
+  '.rb': 'Ruby', '.php': 'PHP', '.cs': 'C#', '.sh': 'Shell',
+};
+
+const LANGUAGE_MANIFEST_MAP = {
+  'package.json': 'JavaScript',
+  'pyproject.toml': 'Python',
+  'requirements.txt': 'Python',
+  'go.mod': 'Go',
+  'Cargo.toml': 'Rust',
+  'pom.xml': 'Java',
+  'Gemfile': 'Ruby',
+};
+
+const PROFILE_GENERATION_SYSTEM_PROMPT = [
+  'You are an expert DevOps engineer generating a deterministic engineering environment setup profile for a software repository.',
+  'Your output will be executed automatically on a new engineer machine.',
+  'Every step must be safe, idempotent, and specific to this exact repository.',
+  'Output ONLY valid JSON matching this schema exactly.',
+  '{',
+  '  "profile_name": "string",',
+  '  "tech_stack": ["string"],',
+  '  "steps": [{"key": "snake_case", "name": "string", "description": "string", "command": "string or null", "check_command": "string or null", "requires_human": false, "category": "dependency|environment|service|access|verification"}],',
+  '  "env_vars_required": ["string"],',
+  '  "estimated_setup_minutes": 5,',
+  '  "notes": "string"',
+  '}',
+].join('\n');
+
+function normalizePath(pathValue) {
+  return pathValue.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+function globToRegExp(pattern) {
+  const escaped = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*/g, '.*')
+    .replace(/\?/g, '.');
+  return new RegExp(`^${escaped}$`);
+}
+
+function loadOctusignorePatterns(repoPath) {
+  const octusignorePath = join(repoPath, '.octusignore');
+  if (!existsSync(octusignorePath)) return [];
+  return readFileSync(octusignorePath, 'utf-8')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith('#'));
+}
+
+function matchesBlockedPattern(filePath, extraPatterns = []) {
+  const normalized = normalizePath(filePath);
+  const fileName = normalized.split('/').pop() || normalized;
+  return [...BLOCKED_FILES, ...extraPatterns].some((pattern) => {
+    const regex = globToRegExp(normalizePath(pattern));
+    return regex.test(normalized) || regex.test(fileName);
+  });
+}
+
+async function isGitIgnored(repoPath, relativePath) {
+  try {
+    await execa('git', ['check-ignore', '--quiet', '--', relativePath], { cwd: repoPath });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function scrubContent(content) {
+  let scrubbed = content;
+  for (const pattern of SECRET_PATTERNS) {
+    scrubbed = scrubbed.replace(pattern, '[REDACTED]');
+  }
+  return scrubbed;
+}
+
+export function analyzeRepo(repoPath) {
+  const analysis = {
+    projectType: 'generic',
+    hasPackageJson: existsSync(join(repoPath, 'package.json')),
+    hasPyproject: existsSync(join(repoPath, 'pyproject.toml')),
+    hasRequirements: existsSync(join(repoPath, 'requirements.txt')),
+    hasDockerfile: existsSync(join(repoPath, 'Dockerfile')),
+    hasDockerCompose: existsSync(join(repoPath, 'docker-compose.yml')) || existsSync(join(repoPath, 'docker-compose.yaml')),
+    hasReadme: existsSync(join(repoPath, 'README.md')),
+    hasMakefile: existsSync(join(repoPath, 'Makefile')),
+    hasEnvExample: existsSync(join(repoPath, '.env.example')) || existsSync(join(repoPath, '.env.sample')),
+    frameworks: [],
+    matchesKnownProfile: null,
+  };
+
+  if (analysis.hasPackageJson) {
+    analysis.projectType = 'node';
+    try {
+      const pkg = JSON.parse(readFileSync(join(repoPath, 'package.json'), 'utf-8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps.next) analysis.frameworks.push('nextjs');
+      if (deps.react) analysis.frameworks.push('react');
+      if (deps.vue) analysis.frameworks.push('vue');
+      if (deps.express) analysis.frameworks.push('express');
+      if (deps.fastify) analysis.frameworks.push('fastify');
+      if (deps.typescript) analysis.frameworks.push('typescript');
+    } catch {}
+    analysis.matchesKnownProfile = 'demo-node';
+  } else if (analysis.hasPyproject || analysis.hasRequirements) {
+    analysis.projectType = 'python';
+    if (existsSync(join(repoPath, 'manage.py'))) analysis.frameworks.push('django');
+    try {
+      const pyprojectPath = join(repoPath, 'pyproject.toml');
+      const pyproject = existsSync(pyprojectPath) ? readFileSync(pyprojectPath, 'utf-8') : '';
+      if (pyproject.includes('fastapi')) analysis.frameworks.push('fastapi');
+      if (pyproject.includes('flask')) analysis.frameworks.push('flask');
+      if (pyproject.includes('pytest')) analysis.frameworks.push('pytest');
+    } catch {}
+    analysis.matchesKnownProfile = 'demo-python';
+  } else if (existsSync(join(repoPath, 'Cargo.toml'))) {
+    analysis.projectType = 'rust';
+  } else if (existsSync(join(repoPath, 'go.mod'))) {
+    analysis.projectType = 'go';
+  }
+
+  return analysis;
+}
+
+export function generateRuleBasedProfile(repoPath) {
+  const analysis = analyzeRepo(repoPath);
+  const profile = {
+    profile_name: `${analysis.projectType.charAt(0).toUpperCase() + analysis.projectType.slice(1)} Project`,
+    tech_stack: [analysis.projectType, ...analysis.frameworks].filter(Boolean),
+    steps: [],
+    env_vars_required: [],
+    estimated_setup_minutes: 5,
+    notes: 'Rule-based profile generated from current Octus repo analysis.',
+  };
+
+  if (analysis.hasReadme) {
+    profile.steps.push({
+      key: 'read_readme',
+      name: 'Review README',
+      description: 'Familiarize yourself with the project documentation.',
+      command: 'cat README.md | head -100',
+      check_command: 'test -f README.md',
+      requires_human: false,
+      category: 'verification',
+    });
+  }
+
+  if (analysis.projectType === 'node') {
+    profile.steps.push({
+      key: 'install_deps',
+      name: 'Install dependencies',
+      description: 'Install project dependencies.',
+      command: 'npm install',
+      check_command: 'test -d node_modules',
+      requires_human: false,
+      category: 'dependency',
+    });
+    if (analysis.hasEnvExample) {
+      profile.steps.push({
+        key: 'setup_env',
+        name: 'Setup environment variables',
+        description: 'Copy the example env file for local development.',
+        command: 'cp .env.example .env.local 2>/dev/null || cp .env.sample .env.local 2>/dev/null || true',
+        check_command: 'test -f .env.local',
+        requires_human: false,
+        category: 'environment',
+      });
+    }
+    profile.steps.push({
+      key: 'run_tests',
+      name: 'Run test suite',
+      description: 'Run automated tests.',
+      command: 'npm test',
+      check_command: 'npm test -- --passWithNoTests 2>/dev/null || true',
+      requires_human: false,
+      category: 'verification',
+    });
+  } else if (analysis.projectType === 'python') {
+    profile.steps.push({
+      key: 'create_venv',
+      name: 'Create virtual environment',
+      description: 'Create a local virtual environment.',
+      command: 'python3 -m venv .venv',
+      check_command: 'test -d .venv',
+      requires_human: false,
+      category: 'dependency',
+    });
+    profile.steps.push({
+      key: 'install_deps',
+      name: 'Install dependencies',
+      description: 'Install Python dependencies.',
+      command: analysis.hasPyproject ? '.venv/bin/pip install -e ".[dev]"' : '.venv/bin/pip install -r requirements.txt',
+      check_command: '.venv/bin/python --version',
+      requires_human: false,
+      category: 'dependency',
+    });
+  }
+
+  if (analysis.hasDockerCompose) {
+    profile.steps.push({
+      key: 'docker_up',
+      name: 'Start Docker services',
+      description: 'Start required Docker services.',
+      command: 'docker compose up -d',
+      check_command: 'docker compose ps',
+      requires_human: false,
+      category: 'service',
+    });
+  }
+
+  if (analysis.hasMakefile) {
+    profile.steps.push({
+      key: 'make_setup',
+      name: 'Run make setup',
+      description: 'Run the repository make setup/install target if available.',
+      command: 'make setup 2>/dev/null || make install 2>/dev/null || true',
+      check_command: 'test -f Makefile',
+      requires_human: false,
+      category: 'verification',
+    });
+  }
+
+  profile.estimated_setup_minutes = Math.max(5, profile.steps.length * 3 || 5);
+  if (analysis.matchesKnownProfile) {
+    profile.notes += ` Known matcher detected: ${analysis.matchesKnownProfile}.`;
+  }
+  return { profile, analysis };
+}
+
+async function buildDirectoryTree(repoPath, extraPatterns, currentPath = repoPath, depth = 0, maxDepth = 3) {
+  if (depth > maxDepth) return [];
+  const entries = readdirSync(currentPath, { withFileTypes: true })
+    .filter((entry) => !CONTEXT_EXCLUDED_DIRS.has(entry.name))
+    .sort((a, b) => a.name.localeCompare(b.name));
+  const lines = [];
+  for (const entry of entries) {
+    const fullPath = join(currentPath, entry.name);
+    const relPath = normalizePath(relative(repoPath, fullPath));
+    if (matchesBlockedPattern(relPath, extraPatterns)) continue;
+    if (await isGitIgnored(repoPath, relPath)) continue;
+    lines.push(`${'  '.repeat(depth)}${entry.name}${entry.isDirectory() ? '/' : ''}`);
+    if (entry.isDirectory()) {
+      lines.push(...await buildDirectoryTree(repoPath, extraPatterns, fullPath, depth + 1, maxDepth));
+    }
+  }
+  return lines;
+}
+
+async function collectRelevantFiles(repoPath, extraPatterns) {
+  const selected = [];
+  for (const fileName of CONTEXT_ROOT_FILES) {
+    const fullPath = join(repoPath, fileName);
+    if (!existsSync(fullPath)) continue;
+    const relPath = normalizePath(relative(repoPath, fullPath));
+    if (matchesBlockedPattern(relPath, extraPatterns)) continue;
+    if (await isGitIgnored(repoPath, relPath)) continue;
+    selected.push(fullPath);
+  }
+
+  const stack = [repoPath];
+  while (stack.length > 0 && selected.length < 20) {
+    const dir = stack.pop();
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (CONTEXT_EXCLUDED_DIRS.has(entry.name)) continue;
+      const fullPath = join(dir, entry.name);
+      const relPath = normalizePath(relative(repoPath, fullPath));
+      if (matchesBlockedPattern(relPath, extraPatterns)) continue;
+      if (await isGitIgnored(repoPath, relPath)) continue;
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      const ext = extname(entry.name).toLowerCase();
+      if (!LANGUAGE_SUFFIX_MAP[ext]) continue;
+      if (!selected.includes(fullPath)) selected.push(fullPath);
+      if (selected.length >= 20) break;
+    }
+  }
+  return selected;
+}
+
+async function collectRepoContext(repoPath) {
+  const extraPatterns = loadOctusignorePatterns(repoPath);
+  const directoryTree = (await buildDirectoryTree(repoPath, extraPatterns)).join('\n');
+  const relevantFiles = await collectRelevantFiles(repoPath, extraPatterns);
+  const fileExcerpts = relevantFiles.map((filePath) => ({
+    relative_path: normalizePath(relative(repoPath, filePath)),
+    content: scrubContent(
+      readFileSync(filePath, 'utf-8').split(/\r?\n/).slice(0, 200).join('\n').slice(0, 12000)
+    ),
+  }));
+
+  const languageSignals = new Set();
+  const packageManagers = new Set();
+  for (const filePath of relevantFiles) {
+    const relPath = normalizePath(relative(repoPath, filePath));
+    const fileName = relPath.split('/').pop() || relPath;
+    const ext = extname(fileName).toLowerCase();
+    if (LANGUAGE_SUFFIX_MAP[ext]) languageSignals.add(LANGUAGE_SUFFIX_MAP[ext]);
+    if (LANGUAGE_MANIFEST_MAP[fileName]) languageSignals.add(LANGUAGE_MANIFEST_MAP[fileName]);
+    if (fileName === 'package.json') packageManagers.add('npm');
+    if (fileName === 'pyproject.toml') packageManagers.add('poetry or pip');
+  }
+
+  return {
+    repo_name: resolve(repoPath).split('/').pop(),
+    directory_tree: directoryTree,
+    file_excerpts: fileExcerpts,
+    tech_stack_signals: {
+      languages: [...languageSignals],
+      frameworks: [],
+      package_managers: [...packageManagers],
+    },
+  };
+}
+
+function contextPrompt(context, repoPath) {
+  const sections = [
+    'Return raw JSON only. Do not include markdown fences, comments, or explanatory text.',
+    `Repository name: ${context.repo_name}`,
+    `Repository path: ${repoPath}`,
+    'Directory tree:',
+    context.directory_tree || '(empty)',
+    'Tech stack signals:',
+    `Languages: ${context.tech_stack_signals.languages.join(', ') || 'unknown'}`,
+    `Frameworks: ${context.tech_stack_signals.frameworks.join(', ') || 'unknown'}`,
+    `Package managers: ${context.tech_stack_signals.package_managers.join(', ') || 'unknown'}`,
+  ];
+  for (const excerpt of context.file_excerpts) {
+    sections.push(`File: ${excerpt.relative_path}`);
+    sections.push(excerpt.content);
+  }
+  return sections.join('\n\n');
+}
+
+function stripMarkdownFences(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith('```')) return trimmed;
+  return trimmed.replace(/^```[a-zA-Z]*\n?/, '').replace(/\n?```$/, '').trim();
+}
+
+export async function generateProfileWithAi(repoPath) {
+  const apiKey = process.env.ANTHROPIC_API_KEY?.trim();
+  if (!apiKey) {
+    return { ...generateRuleBasedProfile(repoPath), usedAi: false, fallbackReason: 'ANTHROPIC_API_KEY not set — using rule-based profile generation.' };
+  }
+
+  try {
+    const context = await collectRepoContext(repoPath);
+    const anthropic = new Anthropic({ apiKey });
+    const completion = await anthropic.messages.create({
+      model: 'claude-sonnet-4-5',
+      max_tokens: 2500,
+      temperature: 0,
+      system: PROFILE_GENERATION_SYSTEM_PROMPT,
+      messages: [{ role: 'user', content: contextPrompt(context, repoPath) }],
+    });
+    const rawText = completion.content.map((block) => (typeof block.text === 'string' ? block.text : '')).join('\n').trim();
+    const parsed = JSON.parse(stripMarkdownFences(rawText));
+    return {
+      profile: {
+        profile_name: parsed.profile_name || 'Generated Profile',
+        tech_stack: Array.isArray(parsed.tech_stack) ? parsed.tech_stack : [],
+        steps: Array.isArray(parsed.steps) ? parsed.steps : [],
+        env_vars_required: Array.isArray(parsed.env_vars_required) ? parsed.env_vars_required : [],
+        estimated_setup_minutes: Number.isFinite(parsed.estimated_setup_minutes) ? parsed.estimated_setup_minutes : 5,
+        notes: typeof parsed.notes === 'string' ? parsed.notes : '',
+      },
+      analysis: analyzeRepo(repoPath),
+      usedAi: true,
+      fallbackReason: null,
+    };
+  } catch (error) {
+    return {
+      ...generateRuleBasedProfile(repoPath),
+      usedAi: false,
+      fallbackReason: `AI profile generation failed, using rule-based fallback: ${error.message}`,
+    };
+  }
+}
+
+export function toYamlDraft(profile) {
+  return YAML.stringify({
+    name: profile.profile_name,
+    description: profile.notes || 'Auto-generated onboarding profile',
+    generated_at: new Date().toISOString(),
+    steps: profile.steps.map((step) => ({
+      step_key: step.key,
+      title: step.name,
+      description: step.description,
+      command: step.command,
+      check_command: step.check_command,
+      requires_human: step.requires_human,
+      category: step.category,
+    })),
+  }, { indent: 2 });
+}
+
+export default { analyzeRepo, generateRuleBasedProfile, generateProfileWithAi, toYamlDraft };

package/src/lib/ui.js

@@ -0,0 +1,186 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+import ora from 'ora';
+import Table from 'cli-table3';
+import logSymbols from 'log-symbols';
+import figures from 'figures';
+
+/**
+ * Create a spinner
+ */
+export function spinner(text) {
+  return ora({
+    text,
+    spinner: 'dots',
+    color: 'cyan'
+  });
+}
+
+/**
+ * Success message
+ */
+export function success(message) {
+  console.log(`${logSymbols.success} ${chalk.green(message)}`);
+}
+
+/**
+ * Error message
+ */
+export function error(message) {
+  console.log(`${logSymbols.error} ${chalk.red(message)}`);
+}
+
+/**
+ * Warning message
+ */
+export function warning(message) {
+  console.log(`${logSymbols.warning} ${chalk.yellow(message)}`);
+}
+
+/**
+ * Info message
+ */
+export function info(message) {
+  console.log(`${logSymbols.info} ${chalk.blue(message)}`);
+}
+
+/**
+ * Print a boxed message
+ */
+export function box(content, options = {}) {
+  console.log(boxen(content, {
+    padding: 1,
+    margin: 1,
+    borderStyle: 'round',
+    borderColor: 'cyan',
+    ...options
+  }));
+}
+
+/**
+ * Print a table
+ */
+export function table(headers, rows, options = {}) {
+  const t = new Table({
+    head: headers.map(h => chalk.cyan.bold(h)),
+    style: { head: [], border: [] },
+    ...options
+  });
+  rows.forEach(row => t.push(row));
+  console.log(t.toString());
+}
+
+/**
+ * Print key-value pairs
+ */
+export function keyValue(pairs) {
+  const maxKeyLen = Math.max(...pairs.map(([k]) => k.length));
+  pairs.forEach(([key, value]) => {
+    const paddedKey = key.padEnd(maxKeyLen);
+    console.log(`  ${chalk.dim(paddedKey)}  ${value}`);
+  });
+}
+
+/**
+ * Print a step in a process
+ */
+export function step(number, total, text, status = 'pending') {
+  const statusIcon = {
+    pending: chalk.dim(figures.circle),
+    running: chalk.cyan(figures.pointer),
+    success: chalk.green(figures.tick),
+    failed: chalk.red(figures.cross),
+    skipped: chalk.yellow(figures.line)
+  }[status] || figures.circle;
+
+  console.log(`  ${statusIcon} ${chalk.dim(`[${number}/${total}]`)} ${text}`);
+}
+
+/**
+ * Print a header/title
+ */
+export function header(text) {
+  console.log();
+  console.log(chalk.bold.cyan(text));
+  console.log(chalk.dim('─'.repeat(text.length + 4)));
+}
+
+/**
+ * Print a section divider
+ */
+export function divider() {
+  console.log();
+}
+
+/**
+ * Mask a secret (show first 4 and last 4 chars)
+ */
+export function maskSecret(secret) {
+  if (!secret || secret.length < 12) {
+    return '••••••••';
+  }
+  return `${secret.slice(0, 4)}${'•'.repeat(8)}${secret.slice(-4)}`;
+}
+
+/**
+ * Format a status badge
+ */
+export function statusBadge(status) {
+  const badges = {
+    success: chalk.bgGreen.black(' SUCCESS '),
+    failed: chalk.bgRed.white(' FAILED '),
+    running: chalk.bgBlue.white(' RUNNING '),
+    pending: chalk.bgGray.white(' PENDING '),
+    blocked: chalk.bgYellow.black(' BLOCKED '),
+    skipped: chalk.bgGray.white(' SKIPPED ')
+  };
+  return badges[status] || chalk.bgGray.white(` ${status.toUpperCase()} `);
+}
+
+/**
+ * Print failure panel (like Rich panel)
+ */
+export function failurePanel(title, content) {
+  console.log();
+  console.log(boxen(content, {
+    title: chalk.red.bold(title),
+    titleAlignment: 'left',
+    padding: 1,
+    margin: { top: 0, bottom: 0, left: 2, right: 2 },
+    borderStyle: 'double',
+    borderColor: 'red'
+  }));
+}
+
+/**
+ * Print success panel
+ */
+export function successPanel(title, content) {
+  console.log();
+  console.log(boxen(content, {
+    title: chalk.green.bold(title),
+    titleAlignment: 'left',
+    padding: 1,
+    margin: { top: 0, bottom: 0, left: 2, right: 2 },
+    borderStyle: 'round',
+    borderColor: 'green'
+  }));
+}
+
+export default {
+  spinner,
+  success,
+  error,
+  warning,
+  info,
+  box,
+  table,
+  keyValue,
+  step,
+  header,
+  divider,
+  maskSecret,
+  statusBadge,
+  failurePanel,
+  successPanel
+};

package/src/lib/version.js

@@ -0,0 +1 @@
+export const version = '0.3.0';