@gitset-dev/cli 1.2.1 → 2.0.0

package/src/commands/dependabot-resolver.js

@@ -0,0 +1,314 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const DependabotAnalyzer = require('../utils/dependabot-analyzer');
+const { log, askQuestion, selectOption, colors } = require('../utils/ui');
+
+function execCommand(cmd) {
+    try {
+        return execSync(cmd, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    } catch (err) {
+        return null;
+    }
+}
+
+function getLocalVersion(dependencyName, manifestPath) {
+    try {
+        const fullPath = path.resolve(process.cwd(), manifestPath);
+        if (!fs.existsSync(fullPath)) return null;
+
+        const content = fs.readFileSync(fullPath, 'utf8');
+
+        if (manifestPath.endsWith('package.json')) {
+            const pkg = JSON.parse(content);
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            const version = deps[dependencyName];
+            return version ? version.replace(/^[\^~]/, '') : null;
+        }
+
+        if (manifestPath.endsWith('package-lock.json')) {
+            const lock = JSON.parse(content);
+
+            if (lock.packages) {
+                const pkgKey = `node_modules/${dependencyName}`;
+                if (lock.packages[pkgKey]) {
+                    return lock.packages[pkgKey].version;
+                }
+            }
+
+            if (lock.dependencies && lock.dependencies[dependencyName]) {
+                return lock.dependencies[dependencyName].version;
+            }
+            return null;
+        }
+
+        if (manifestPath.endsWith('requirements.txt')) {
+            const regex = new RegExp(`^${dependencyName}==(.*)$`, 'm');
+            const match = content.match(regex);
+            return match ? match[1] : null;
+        }
+
+        return null;
+    } catch (e) {
+        return null;
+    }
+}
+
+async function fetchAlerts(owner, repo, token) {
+    const url = `https://api.github.com/repos/${owner}/${repo}/dependabot/alerts?state=open&per_page=100`;
+    try {
+        const response = await fetch(url, {
+            headers: {
+                'Authorization': `token ${token}`,
+                'Accept': 'application/vnd.github+json',
+                'X-GitHub-Api-Version': '2022-11-28'
+            }
+        });
+
+        if (!response.ok) {
+            if (response.status === 401) throw new Error('Unauthorized (check token scopes)');
+            if (response.status === 403) throw new Error('Forbidden (check permissions/dependabot access)');
+            if (response.status === 404) throw new Error('Repo not found or no access');
+            throw new Error(`API Error: ${response.status} ${response.statusText}`);
+        }
+
+        return await response.json();
+    } catch (e) {
+        throw e;
+    }
+}
+
+async function commandDependabotResolver(config, args) {
+    const token = config?.github_token;
+    const ghStatus = execCommand('gh auth status');
+
+    if (!token && !ghStatus) {
+        log('✗ No GitHub authentication found.', 'red');
+        log('  Run "gh auth login" (GitHub CLI) and try again.', 'yellow');
+        return 1;
+    }
+
+    const analyzer = new DependabotAnalyzer();
+
+    let owner, repo;
+    try {
+        const remoteUrl = execCommand('git config --get remote.origin.url');
+        if (!remoteUrl) throw new Error('No remote origin found');
+
+        const match = remoteUrl.match(/[:/]([^/]+)\/([^/.]+)(?:\.git)?$/);
+        if (match) {
+            owner = match[1];
+            repo = match[2];
+        }
+    } catch (e) {
+        log('✗ Could not detect repository info from git config', 'red');
+        return;
+    }
+
+    if (!owner || !repo) {
+        log('✗ Invalid repository info detected', 'red');
+        return;
+    }
+
+    const shouldResolve = args.includes('--resolve');
+    const subcommand = shouldResolve ? 'resolve' : 'list';
+
+    if (subcommand === 'list' || subcommand === 'resolve') {
+        log(`\n→ Fetching Dependabot alerts for ${owner}/${repo}...\n`, 'cyan');
+
+        try {
+            let alerts = [];
+            let tokenError = null;
+
+            if (token) {
+                try {
+                    alerts = await fetchAlerts(owner, repo, token);
+                } catch (e) {
+                    tokenError = e;
+
+                    if (e.message.includes('Unauthorized') || e.message.includes('Forbidden')) {
+                        log(`⚠ Stored token failed (${e.message}).`, 'yellow');
+                        log('→ Falling back to local "gh" CLI...', 'cyan');
+                    } else {
+                        throw e;
+                    }
+                }
+            }
+
+            if (!token || (tokenError && (tokenError.message.includes('Unauthorized') || tokenError.message.includes('Forbidden')))) {
+                try {
+                    const alertsJson = execCommand(`gh api "/repos/${owner}/${repo}/dependabot/alerts?state=open&per_page=100"`);
+                    if (!alertsJson) {
+                        throw new Error('Failed to fetch alerts via gh CLI (check "gh auth status" and scopes)');
+                    }
+                    alerts = JSON.parse(alertsJson);
+                } catch (ghError) {
+                    if (tokenError) {
+                        throw new Error(`Both methods failed.\n  Token: ${tokenError.message}\n  CLI: ${ghError.message}\n  (Note: Dependabot alerts require 'security_events' scope)`);
+                    } else {
+                        throw ghError;
+                    }
+                }
+            }
+
+            if (!alerts || alerts.length === 0) {
+                log('✓ No open Dependabot alerts found!', 'green');
+                return;
+            }
+
+            const analyzedAlerts = [];
+
+            for (const alert of alerts) {
+                const depName = alert.dependency.package.name;
+                const ecosystem = alert.dependency.package.ecosystem;
+                const manifestPath = alert.dependency.manifest_path;
+
+                let patchedVersion = null;
+
+                if (alert.security_vulnerability && alert.security_vulnerability.first_patched_version) {
+                    patchedVersion = alert.security_vulnerability.first_patched_version.identifier;
+                }
+
+                else if (alert.security_advisory && alert.security_advisory.vulnerabilities) {
+                    const v = alert.security_advisory.vulnerabilities.find(v => v.package.name === depName);
+                    if (v && v.first_patched_version) {
+                        patchedVersion = v.first_patched_version.identifier;
+                    }
+                }
+
+                else if (alert.security_advisory && alert.security_advisory.patched_versions && alert.security_advisory.patched_versions.length > 0) {
+                    patchedVersion = alert.security_advisory.patched_versions[0].identifier;
+                }
+
+                if (!patchedVersion) {
+                    continue;
+                }
+
+                const localVersion = getLocalVersion(depName, manifestPath);
+
+                let risk = { level: 'UNKNOWN', reason: 'Local version not found' };
+                if (localVersion) {
+                    risk = analyzer.calculateRisk(localVersion, patchedVersion, ecosystem);
+                }
+
+                analyzedAlerts.push({
+                    id: alert.number,
+                    depName,
+                    localVersion: localVersion || '?',
+                    patchedVersion,
+                    severity: alert.security_advisory.severity,
+                    risk,
+                    manifestPath,
+                    ecosystem,
+                    url: alert.html_url
+                });
+            }
+
+            log('ID   | Severity | Dependency       | Version Delta       | Risk', 'blue');
+            log('-----|----------|------------------|---------------------|----------------', 'blue');
+
+            analyzedAlerts.forEach(a => {
+                const delta = `${a.localVersion} -> ${a.patchedVersion}`;
+                const riskColor = a.risk.level === 'RISK_NONE' ? 'green' :
+                    a.risk.level === 'RISK_LOW_BEHAVIORAL' ? 'cyan' :
+                        a.risk.level === 'RISK_MODERATE_API' ? 'yellow' : 'red';
+
+                const paint = colors[riskColor] || ((s) => s);
+                console.log(
+                    `${a.id.toString().padEnd(4)} | ` +
+                    `${a.severity.padEnd(8)} | ` +
+                    `${a.depName.padEnd(16)} | ` +
+                    `${delta.padEnd(19)} | ` +
+                    paint(a.risk.level)
+                );
+            });
+            log('');
+
+            if (subcommand === 'resolve') {
+                const isDryRun = args.includes('--dry-run');
+                const autoResolvable = analyzedAlerts.filter(a => a.risk.level === 'RISK_NONE');
+
+                if (autoResolvable.length === 0) {
+                    log('No RISK_NONE alerts found for auto-resolution.', 'yellow');
+                    return;
+                }
+
+                log(`Found ${autoResolvable.length} auto-resolvable alerts (RISK_NONE).`, 'green');
+
+                if (isDryRun) {
+                    log('\n=== DRY RUN: Proposed Actions ===', 'pink');
+                    autoResolvable.forEach(alert => {
+                        console.log(`\n[Alert #${alert.id}] ${alert.depName}`);
+                        console.log(`  Update: ${alert.localVersion} -> ${alert.patchedVersion}`);
+                        console.log(`  Action: Update ${alert.manifestPath} locally`);
+                    });
+                    return;
+                }
+
+                const confirm = await askQuestion('Do you want to apply these updates locally? (y/n): ');
+
+                if (confirm.toLowerCase() === 'y') {
+                    log('\n→ Applying updates...', 'cyan');
+
+                    for (const alert of autoResolvable) {
+                        log(`\n[${alert.depName}] Updating to ${alert.patchedVersion}...`, 'blue');
+
+                        try {
+                            if (alert.ecosystem === 'npm') {
+                                const pkgPath = path.resolve(process.cwd(), 'package.json');
+                                let saveDev = false;
+                                if (fs.existsSync(pkgPath)) {
+                                    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+                                    if (pkg.devDependencies && pkg.devDependencies[alert.depName]) {
+                                        saveDev = true;
+                                    }
+                                }
+
+                                try {
+                                    execCommand(`npm install ${alert.depName}@${alert.patchedVersion} ${saveDev ? '--save-dev' : ''}`);
+                                    log(`  ✓ Updated ${alert.depName}`, 'green');
+                                } catch (err) {
+                                    log(`  ✗ npm install failed: ${err.message}`, 'red');
+                                    throw err;
+                                }
+                            } else {
+                                const fullPath = path.resolve(process.cwd(), alert.manifestPath);
+                                if (fs.existsSync(fullPath)) {
+                                    let content = fs.readFileSync(fullPath, 'utf8');
+                                    let newContent = content;
+
+                                    if (alert.ecosystem === 'pip') {
+                                        newContent = content.replace(new RegExp(`^${alert.depName}==.*$`, 'm'), `${alert.depName}==${alert.patchedVersion}`);
+                                    }
+
+                                    if (newContent !== content) {
+                                        fs.writeFileSync(fullPath, newContent);
+                                        log(`  ✓ Updated ${alert.manifestPath}`, 'green');
+                                    } else {
+                                        log(`  → Could not replace version in ${alert.manifestPath}`, 'yellow');
+                                    }
+                                } else {
+                                    log(`  ✗ File not found: ${alert.manifestPath}`, 'red');
+                                }
+                            }
+                        } catch (e) {
+                            log(`  ✗ Failed to resolve ${alert.depName}: ${e.message}`, 'red');
+                        }
+                    }
+
+                    log('\n✓ Updates completed!', 'green');
+                    log('● Run "gitset commit" to review and commit these changes.', 'pink');
+                }
+            }
+        } catch (e) {
+            log(`✗ Error: ${e.message}`, 'red');
+            if (e.message.includes('404')) {
+                log('  (Make sure Dependabot alerts are enabled for this repo)', 'yellow');
+            }
+        }
+    } else {
+        log('Usage: gitset dependabot [--resolve]', 'yellow');
+    }
+}
+
+module.exports = commandDependabotResolver;

package/src/commands/gitignore.js

@@ -0,0 +1,110 @@
+'use strict';
+
+/**
+ * `gitset gitignore` — local BYOAI .gitignore generation.
+ * Auto-detects the stack locally, generates via the user's own provider
+ * (vendored lib/ai through lib/generate-local). No backend, no gitset_key.
+ *
+ * Flags: --select (type stacks) | --<stack> ... | --provider --model
+ *        --append --force --print
+ */
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const genLocal = require('../../lib/generate-local');
+
+const tty = () => process.stdout.isTTY;
+const c = (code, s) => (tty() ? `\x1b[${code}m${s}\x1b[0m` : s);
+const ask = (q) => new Promise((r) => {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  rl.question(q, (a) => { rl.close(); r(a.trim()); });
+});
+function flag(argv, n) {
+  const i = argv.indexOf(n);
+  return i !== -1 && argv[i + 1] && !argv[i + 1].startsWith('-') ? argv[i + 1] : null;
+}
+
+const DETECT = {
+  'package.json': ['Node'], 'requirements.txt': ['Python'], 'pyproject.toml': ['Python'],
+  'Pipfile': ['Python'], 'go.mod': ['Go'], 'Cargo.toml': ['Rust'], 'Gemfile': ['Ruby'],
+  'pom.xml': ['Java', 'Maven'], 'build.gradle': ['Java', 'Gradle'], 'composer.json': ['PHP'],
+  'mix.exs': ['Elixir'], 'CMakeLists.txt': ['C++', 'CMake'], 'pubspec.yaml': ['Dart', 'Flutter'],
+  'tsconfig.json': ['TypeScript'], 'next.config.js': ['Next.js'], 'Dockerfile': ['Docker'],
+};
+
+function detectStacks(cwd) {
+  const found = new Set();
+  if (process.platform === 'darwin') found.add('macOS');
+  if (process.platform === 'win32') found.add('Windows');
+  if (process.platform === 'linux') found.add('Linux');
+  let files = [];
+  try { files = fs.readdirSync(cwd); } catch {  }
+  for (const f of files) (DETECT[f] || []).forEach((s) => found.add(s));
+  return [...found];
+}
+
+async function runGitignoreCommand(argv) {
+  const cwd = process.cwd();
+  const printOnly = argv.includes('--print');
+  const nonInteractive = printOnly || !process.stdin.isTTY || argv.includes('--yes') || argv.includes('-y');
+
+  const RESERVED = new Set(['select', 'provider', 'model', 'append', 'force', 'print', 'yes']);
+  let stacks = argv.filter((a) => a.startsWith('--') && !RESERVED.has(a.slice(2)) && a !== '-y').map((a) => a.slice(2));
+
+  if (argv.includes('--select')) {
+    if (nonInteractive) { console.error(`${c('31', '✗')} --select needs a TTY. Pass stacks as --node --python …`); return 1; }
+    const ans = await ask('Stacks/tools (comma separated, e.g. Node, TypeScript, Docker): ');
+    stacks = ans.split(',').map((s) => s.trim()).filter(Boolean);
+  } else if (stacks.length === 0) {
+    stacks = detectStacks(cwd);
+    if (stacks.length === 0) {
+      console.error(`${c('31', '✗')} Could not detect a stack. Use --select or --<stack> (e.g. --node).`);
+      return 1;
+    }
+    console.log(`${c('36', 'detected')}: ${stacks.join(', ')}`);
+    if (!nonInteractive) {
+      const ok = (await ask('Generate .gitignore for these? [Y/n] ')).toLowerCase();
+      if (ok === 'n') { console.log('Aborted.'); return 0; }
+    }
+  }
+
+  const giPath = path.join(cwd, '.gitignore');
+  const existing = fs.existsSync(giPath) ? fs.readFileSync(giPath, 'utf8') : '';
+
+  let result;
+  try {
+    process.stderr.write(c('90', `… generating .gitignore (${stacks.join(', ')})\n`));
+    result = await genLocal.generate({
+      tool: 'gitignore',
+      ctx: { stack: stacks.join(', '), previous: argv.includes('--append') ? existing : '' },
+      provider: flag(argv, '--provider'),
+      model: flag(argv, '--model'),
+      maxTokens: 2048,
+    });
+  } catch (e) {
+    if (e instanceof genLocal.AIError) { console.error(`${c('31', '✗')} AI provider error (${e.code}): ${e.message}`); return 2; }
+    console.error(`${c('31', '✗')} ${e.message}`);
+    return /gitset config/.test(e.message || '') ? 1 : 2;
+  }
+
+  const body = result.text.trim() + '\n';
+  if (printOnly) { process.stdout.write(body); return 0; }
+
+  let finalContent = body;
+  let mode = 'created';
+  if (existing) {
+    let action = argv.includes('--append') ? 'append' : argv.includes('--force') ? 'overwrite' : null;
+    if (!action) {
+      if (nonInteractive) { console.error(`${c('31', '✗')} .gitignore exists. Use --append or --force.`); return 1; }
+      action = (await ask('.gitignore exists — [a]ppend / [o]verwrite / [c]ancel? ')).toLowerCase();
+      action = action === 'a' ? 'append' : action === 'o' ? 'overwrite' : 'cancel';
+    }
+    if (action === 'cancel') { console.log('Aborted.'); return 0; }
+    if (action === 'append') { finalContent = existing.replace(/\n*$/, '\n') + '\n# --- added by gitset ---\n' + body; mode = 'updated'; }
+  }
+  fs.writeFileSync(giPath, finalContent);
+  console.log(`${c('32', '✓')} .gitignore ${mode} (${stacks.join(', ')}, via ${result.provider})`);
+  return 0;
+}
+
+module.exports = { runGitignoreCommand };

package/src/commands/init.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * `gitset init` — scaffold local template files in ~/.gitset/templates.
+ * No auth, no backend (Gitset v2 is BYOAI: there is no login).
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const theme = require('../utils/theme');
+
+const DIR = process.env.GITSET_CONFIG_DIR || path.join(os.homedir(), '.gitset');
+const TPL_DIR = path.join(DIR, 'templates');
+
+const TEMPLATES = {
+  'commit.md': `# Commit style\nUse Conventional Commits. Imperative subject <= 72 chars.\nBody explains the WHY for non-trivial changes.\n`,
+  'pr.md': `## Summary\n\n## Changes\n\n## Testing\n`,
+  'issue.md': `## Summary\n\n## Steps / Acceptance criteria\n\n## Scope\n`,
+  'readme.md': `# {{project}}\n\n> short description\n\n## Install\n\n## Usage\n`,
+  'release.md': `## Highlights\n\n## Features\n\n## Fixes\n`,
+};
+
+function runInitCommand() {
+  fs.mkdirSync(TPL_DIR, { recursive: true, mode: 0o700 });
+  let created = 0;
+  for (const [name, body] of Object.entries(TEMPLATES)) {
+    const f = path.join(TPL_DIR, name);
+    if (!fs.existsSync(f)) { fs.writeFileSync(f, body); created++; }
+  }
+  console.log(`${theme.success('✓')} Templates ready at ${TPL_DIR} (${created} created, ${Object.keys(TEMPLATES).length - created} existing)`);
+  console.log(theme.bold('\nGitset is BYOAI — no login required. Next:'));
+  console.log(`  ${theme.accent('gitset config')}                setup wizard (or gitset config set <provider> --key <key>)`);
+  console.log(`  ${theme.accent('gitset commit')}                generate from staged changes`);
+  console.log(`  ${theme.accent('gitset template edit commit')}  customize this tool's format\n`);
+  return 0;
+}
+
+module.exports = { runInitCommand };

package/src/commands/labelspack.js

@@ -0,0 +1,94 @@
+'use strict';
+
+/**
+ * `gitset labelspack` — manage & apply a label pack. Local pack +
+ * the user's `gh` CLI only. No backend, injection-safe (arg-array exec).
+ *
+ *   gitset labelspack            list the pack
+ *   gitset labelspack --apply    create/update those labels in the repo via gh
+ *   gitset labelspack --init     write the default pack to ~/.gitset/labels.md
+ *   gitset labelspack --add --name x --color hex --description "..."
+ */
+const { execFileSync } = require('child_process');
+const readline = require('readline');
+const { getLabels, addLabel, writeDefaultPack, getRepoLabels } = require('../utils/labels');
+
+const tty = () => process.stdout.isTTY;
+const c = (code, s) => (tty() ? `\x1b[${code}m${s}\x1b[0m` : s);
+const ask = (q) => new Promise((r) => {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  rl.question(q, (a) => { rl.close(); r(a.trim()); });
+});
+const flag = (argv, n) => {
+  const i = argv.indexOf(n);
+  return i !== -1 && argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[i + 1] : null;
+};
+
+function ghAvailable() {
+  try { execFileSync('gh', ['--version'], { stdio: 'ignore' }); return true; } catch { return false; }
+}
+
+async function runLabelspackCommand(argv) {
+  if (argv.includes('--init')) {
+    const f = writeDefaultPack();
+    console.log(`${c('32', '✓')} Wrote default label pack → ${f}`);
+    return 0;
+  }
+
+  if (argv.includes('--add')) {
+    let name = flag(argv, '--name');
+    let color = flag(argv, '--color');
+    let description = flag(argv, '--description');
+    if (!name) {
+      if (!process.stdin.isTTY) { console.error(`${c('31', '✗')} --add needs --name (and optionally --color/--description).`); return 1; }
+      name = await ask('Label name: ');
+      color = await ask('Color (hex, blank=random): ');
+      description = await ask('Description: ');
+    }
+    if (!name) { console.error(`${c('31', '✗')} Name required.`); return 1; }
+    addLabel({ name, color: color || '', description: description || '' });
+    console.log(`${c('32', '✓')} Added "${name}" to the pack.`);
+    return 0;
+  }
+
+  const { source, labels } = getLabels();
+
+  if (!argv.includes('--apply') && !argv.includes('--sync')) {
+    console.log(c('1', `\nLabel pack (${source}) — ${labels.length} labels\n`));
+    for (const l of labels) {
+      console.log(`  ${c('36', l.name)}${l.description ? `  ${c('90', l.description)}` : ''}`);
+    }
+    console.log(c('90', '\nApply to the current repo:  gitset labelspack --apply\n'));
+    return 0;
+  }
+
+  if (!ghAvailable()) {
+    console.error(`${c('31', '✗')} GitHub CLI \`gh\` not found / not authenticated.`);
+    return 1;
+  }
+  if (!process.stdin.isTTY || argv.includes('--yes') || argv.includes('-y')) {
+  } else {
+    const ok = (await ask(`Apply ${labels.length} labels (${source}) to the current repo? [y/N] `)).toLowerCase();
+    if (ok !== 'y') { console.log('Aborted.'); return 0; }
+  }
+
+  const existing = new Set(getRepoLabels().map((l) => l.name));
+  let created = 0; let updated = 0; let failed = 0;
+  for (const l of labels) {
+    const color = String(l.color || '').replace('#', '') || 'ededed';
+    const sub = existing.has(l.name) ? 'edit' : 'create';
+    try {
+      execFileSync('gh', ['label', sub, l.name, '--color', color, '--description', l.description || ''],
+        { stdio: 'ignore' });
+      if (sub === 'create') { created++; console.log(`${c('32', '✓')} created ${l.name}`); }
+      else { updated++; console.log(`${c('36', '↻')} updated ${l.name}`); }
+    } catch {
+      failed++;
+      console.error(`${c('31', '✗')} failed ${l.name}`);
+    }
+  }
+  console.log(c('1', `\n${created} created · ${updated} updated · ${failed} failed`));
+  return failed > 0 ? 1 : 0;
+}
+
+module.exports = { runLabelspackCommand };