slashdev 0.1.0 → 1.0.0

package/src/commands/setup.js

@@ -0,0 +1,104 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync, readFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { getConfig, setConfig, getSlashdevDir } from '../core/config.js';
+import { installHooks, installSkills, installGstack } from './setup-internals.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PACKAGE_ROOT = join(__dirname, '..', '..');
+
+const CLAUDE_DIR = join(homedir(), '.claude');
+
+const BRAND = chalk.hex('#215ff6');
+
+function validateEmail(email) {
+  if (!email || !email.endsWith('@slashdev.io')) {
+    return 'Email must be a valid @slashdev.io address';
+  }
+  if (!/^[^\s@]+@slashdev\.io$/.test(email)) {
+    return 'Invalid email format';
+  }
+  return true;
+}
+
+export async function setup() {
+  console.log(BRAND('\n  Slashdev Claude Tools Setup\n'));
+
+  // Check if already configured
+  const existingEngineer = getConfig('engineer');
+  if (existingEngineer) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: `Already configured for ${chalk.cyan(existingEngineer)}. Overwrite?`,
+        default: false,
+      },
+    ]);
+    if (!overwrite) {
+      console.log(chalk.yellow('\n  Setup cancelled.\n'));
+      return;
+    }
+  }
+
+  // Prompt for email
+  const { email } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'email',
+      message: 'Enter your Slashdev email (e.g. you@slashdev.io):',
+      validate: validateEmail,
+    },
+  ]);
+
+  const spinner = ora('Installing Slashdev Claude tools...').start();
+
+  try {
+    // Write engineer config
+    setConfig('engineer', email);
+
+    const pkg = JSON.parse(readFileSync(join(PACKAGE_ROOT, 'package.json'), 'utf-8'));
+    setConfig('packageVersion', pkg.version);
+
+    // Ensure Claude directory exists
+    if (!existsSync(CLAUDE_DIR)) {
+      mkdirSync(CLAUDE_DIR, { recursive: true });
+    }
+
+    // Install hooks
+    spinner.text = 'Installing hooks...';
+    const hookResult = installHooks();
+
+    // Install skills
+    spinner.text = 'Installing Claude Code skills...';
+    const skillResult = installSkills();
+
+    // Install gstack skills
+    spinner.text = 'Installing gstack skills...';
+    const gstackResult = installGstack();
+
+    spinner.succeed('Slashdev Claude tools installed');
+
+    console.log('');
+    console.log(`  ${chalk.green('✓')} Engineer:  ${chalk.cyan(email)}`);
+    console.log(`  ${chalk.green('✓')} Hooks:     ${hookResult.installed} installed`);
+    console.log(`  ${chalk.green('✓')} Skills:    ${skillResult.installed} installed`);
+    console.log(`  ${chalk.green('✓')} Gstack:    ${gstackResult.installed} skills installed`);
+    if (gstackResult.warning) {
+      console.log(`  ${chalk.yellow('!')} ${gstackResult.warning}`);
+    }
+    console.log(`  ${chalk.green('✓')} Config:    ${join(getSlashdevDir(), 'config.json')}`);
+    console.log('');
+    console.log(chalk.dim('  Hooks and skills have been installed to ~/.claude/'));
+    console.log(chalk.dim('  Prompt logs will be sent to the Slashdev API for quality review.\n'));
+  } catch (err) {
+    spinner.fail('Setup failed');
+    console.error(chalk.red(`\n  Error: ${err.message}\n`));
+    process.exit(1);
+  }
+}

package/src/commands/update.js

@@ -0,0 +1,60 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { getConfig, setConfig } from '../core/config.js';
+import { setup } from './setup.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PACKAGE_ROOT = join(__dirname, '..', '..');
+
+const BRAND = chalk.hex('#215ff6');
+
+export async function update() {
+  console.log(BRAND('\n  Slashdev Claude Tools Update\n'));
+
+  const engineer = getConfig('engineer');
+  if (!engineer) {
+    console.log(chalk.yellow('  Not configured yet. Running setup instead...\n'));
+    await setup();
+    return;
+  }
+
+  const spinner = ora('Updating hooks and skills...').start();
+
+  try {
+    // Re-import setup internals by calling setup's install functions
+    // We import dynamically to avoid circular deps
+    const { installHooks, installSkills, installGstack } = await import('./setup-internals.js');
+
+    const hookResult = installHooks();
+
+    spinner.text = 'Updating Claude Code skills...';
+    const skillResult = installSkills();
+
+    spinner.text = 'Updating gstack skills...';
+    const gstackResult = installGstack();
+
+    // Update version in config
+    const pkg = JSON.parse(readFileSync(join(PACKAGE_ROOT, 'package.json'), 'utf-8'));
+    setConfig('packageVersion', pkg.version);
+
+    spinner.succeed(`Updated to v${pkg.version}`);
+
+    console.log('');
+    console.log(`  ${chalk.green('✓')} Hooks:   ${hookResult.installed} updated`);
+    console.log(`  ${chalk.green('✓')} Skills:  ${skillResult.installed} updated`);
+    console.log(`  ${chalk.green('✓')} Gstack:  ${gstackResult.installed} skills updated`);
+    if (gstackResult.warning) {
+      console.log(`  ${chalk.yellow('!')} ${gstackResult.warning}`);
+    }
+    console.log(`  ${chalk.green('✓')} Config:  version set to ${pkg.version}`);
+    console.log('');
+  } catch (err) {
+    spinner.fail('Update failed');
+    console.error(chalk.red(`\n  Error: ${err.message}\n`));
+    process.exit(1);
+  }
+}

package/src/connections/index.js

@@ -0,0 +1,449 @@
+import ora from 'ora';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { credentials } from '../core/config.js';
+import { getProvider, getAllProviders, getProviderIds } from './registry.js';
+
+// --- Storage helpers ---
+
+function getStoredConnections() {
+  return credentials.get('connections') || {};
+}
+
+function getStoredConnection(providerId) {
+  const connections = getStoredConnections();
+  return connections[providerId] || null;
+}
+
+function storeConnection(providerId, data) {
+  const provider = getProvider(providerId);
+  const connections = getStoredConnections();
+
+  if (provider?.multiple) {
+    const existing = Array.isArray(connections[providerId]) ? connections[providerId] : [];
+    existing.push({
+      ...data,
+      connectedAt: new Date().toISOString(),
+    });
+    connections[providerId] = existing;
+  } else {
+    connections[providerId] = {
+      ...data,
+      connectedAt: new Date().toISOString(),
+    };
+  }
+
+  credentials.set('connections', connections);
+}
+
+function removeConnection(providerId, entryIndex = null) {
+  const connections = getStoredConnections();
+  const provider = getProvider(providerId);
+
+  if (provider?.multiple && entryIndex !== null) {
+    const entries = connections[providerId] || [];
+    entries.splice(entryIndex, 1);
+    if (entries.length === 0) {
+      delete connections[providerId];
+    } else {
+      connections[providerId] = entries;
+    }
+  } else {
+    delete connections[providerId];
+  }
+
+  credentials.set('connections', connections);
+}
+
+// --- Public API ---
+
+export function isConnected(providerId) {
+  const provider = getProvider(providerId);
+  const stored = getStoredConnection(providerId);
+
+  if (provider?.multiple) {
+    return Array.isArray(stored) && stored.length > 0;
+  }
+
+  return !!stored;
+}
+
+export function getConnection(providerId) {
+  return getStoredConnection(providerId);
+}
+
+export function getConnectionClient(providerId) {
+  const provider = getProvider(providerId);
+  if (!provider) {
+    throw new Error(`Unknown connection: ${providerId}`);
+  }
+
+  const stored = getStoredConnection(providerId);
+  if (!stored) {
+    throw new Error(
+      `Not connected to ${provider.name}. Run \`slashdev connect ${providerId}\` first.`
+    );
+  }
+
+  return provider.createClient(stored);
+}
+
+export async function connect(providerId) {
+  const provider = getProvider(providerId);
+
+  if (!provider) {
+    if (!providerId) {
+      return await connectInteractive();
+    }
+    console.log();
+    console.log(chalk.red(`  Unknown connection: ${providerId}`));
+    console.log(
+      chalk.dim(`  Available: ${getProviderIds().join(', ')}`)
+    );
+    console.log();
+    return;
+  }
+
+  // Multi-entry providers (e.g. servers)
+  if (provider.multiple) {
+    const existing = getStoredConnection(providerId);
+    if (Array.isArray(existing) && existing.length > 0) {
+      console.log();
+      console.log(
+        chalk.hex('#4d7fff')(
+          `  ${existing.length} server${existing.length > 1 ? 's' : ''} currently connected:`
+        )
+      );
+      for (const entry of existing) {
+        console.log(
+          chalk.dim(`    - ${entry.name} (${entry.username}@${entry.host}:${entry.port})`)
+        );
+      }
+    }
+
+    console.log();
+    console.log(chalk.hex('#215ff6').bold(`  Add ${provider.name} Connection`));
+    console.log(chalk.hex('#4d7fff')('  ─────────────────────────────────────────'));
+
+    const creds = await provider.promptForCredentials();
+
+    // Check for duplicate alias
+    const entries = Array.isArray(existing) ? existing : [];
+    const duplicate = entries.find(
+      (e) => e.name.toLowerCase() === creds.name.toLowerCase()
+    );
+    if (duplicate) {
+      console.log();
+      const { overwrite } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'overwrite',
+          message: chalk.hex('#7a9fff')(
+            `A server named "${creds.name}" already exists. Replace it?`
+          ),
+          default: false,
+        },
+      ]);
+
+      if (!overwrite) {
+        console.log(chalk.dim('  Cancelled.'));
+        return;
+      }
+
+      const idx = entries.findIndex(
+        (e) => e.name.toLowerCase() === creds.name.toLowerCase()
+      );
+      removeConnection(providerId, idx);
+    }
+
+    const spinner = ora({
+      text: chalk.hex('#4d7fff')(`Adding ${provider.name.toLowerCase()} connection...`),
+      color: 'blue',
+    }).start();
+
+    const result = await provider.validate(creds);
+
+    if (!result.valid) {
+      spinner.fail(chalk.red(result.error || 'Validation failed.'));
+      return;
+    }
+
+    storeConnection(providerId, creds);
+
+    spinner.succeed(
+      chalk.hex('#4d7fff')(
+        `Added server ${chalk.bold(creds.name)} (${creds.username}@${creds.host}:${creds.port})`
+      )
+    );
+    console.log();
+    return;
+  }
+
+  // Single-entry providers (e.g. GitHub)
+  const existing = getStoredConnection(providerId);
+  if (existing) {
+    console.log();
+    console.log(
+      chalk.hex('#4d7fff')(
+        `  Already connected to ${provider.name}${
+          existing.username ? ` as ${chalk.bold(existing.username)}` : ''
+        }.`
+      )
+    );
+
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: chalk.hex('#7a9fff')('Replace existing connection?'),
+        default: false,
+      },
+    ]);
+
+    if (!overwrite) {
+      return;
+    }
+  }
+
+  console.log();
+  console.log(chalk.hex('#215ff6').bold(`  Connect ${provider.name}`));
+  console.log(chalk.hex('#4d7fff')('  ─────────────────────────────────────────'));
+
+  const creds = await provider.promptForCredentials();
+
+  const spinner = ora({
+    text: chalk.hex('#4d7fff')(`Validating ${provider.name} token...`),
+    color: 'blue',
+  }).start();
+
+  const result = await provider.validate(creds);
+
+  if (!result.valid) {
+    spinner.fail(chalk.red(result.error || 'Validation failed.'));
+    return;
+  }
+
+  const dataToStore = { ...creds };
+  if (result.username) {
+    dataToStore.username = result.username;
+  }
+  storeConnection(providerId, dataToStore);
+
+  spinner.succeed(
+    chalk.hex('#4d7fff')(
+      `Connected to ${provider.name}${
+        result.username ? ` as ${chalk.bold(result.username)}` : ''
+      }!`
+    )
+  );
+  console.log();
+}
+
+async function connectInteractive() {
+  const providers = getAllProviders();
+  const choices = Object.values(providers).map((p) => ({
+    name: `${p.name} — ${p.description}`,
+    value: p.id,
+  }));
+
+  console.log();
+  console.log(chalk.hex('#215ff6').bold('  Connect a Service'));
+  console.log(chalk.hex('#4d7fff')('  ─────────────────────────────────────────'));
+  console.log();
+
+  const { selected } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selected',
+      message: chalk.hex('#7a9fff')('Which service do you want to connect?'),
+      choices,
+    },
+  ]);
+
+  await connect(selected);
+}
+
+export async function disconnect(providerId) {
+  const provider = getProvider(providerId);
+
+  if (!provider) {
+    if (!providerId) {
+      return await disconnectInteractive();
+    }
+    console.log();
+    console.log(chalk.red(`  Unknown connection: ${providerId}`));
+    console.log();
+    return;
+  }
+
+  if (!isConnected(providerId)) {
+    console.log();
+    console.log(chalk.hex('#7a9fff')(`  Not connected to ${provider.name}.`));
+    console.log();
+    return;
+  }
+
+  // Multi-entry providers
+  if (provider.multiple) {
+    const entries = getStoredConnection(providerId);
+
+    if (entries.length === 1) {
+      removeConnection(providerId, 0);
+      console.log();
+      console.log(
+        chalk.hex('#4d7fff')(
+          `  Removed server ${chalk.bold(entries[0].name)}.`
+        )
+      );
+      console.log();
+      return;
+    }
+
+    const choices = entries.map((entry, idx) => ({
+      name: `${entry.name} (${entry.username}@${entry.host}:${entry.port})`,
+      value: idx,
+    }));
+    choices.push({ name: chalk.red('Remove all servers'), value: '__all__' });
+
+    const { selected } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selected',
+        message: chalk.hex('#7a9fff')('Which server do you want to remove?'),
+        choices,
+      },
+    ]);
+
+    if (selected === '__all__') {
+      removeConnection(providerId);
+      console.log();
+      console.log(chalk.hex('#4d7fff')('  Removed all server connections.'));
+      console.log();
+    } else {
+      const entry = entries[selected];
+      removeConnection(providerId, selected);
+      console.log();
+      console.log(
+        chalk.hex('#4d7fff')(`  Removed server ${chalk.bold(entry.name)}.`)
+      );
+      console.log();
+    }
+    return;
+  }
+
+  // Single-entry providers
+  const stored = getStoredConnection(providerId);
+  removeConnection(providerId);
+
+  console.log();
+  console.log(
+    chalk.hex('#4d7fff')(
+      `  Disconnected from ${provider.name}${
+        stored.username ? ` (${stored.username})` : ''
+      }.`
+    )
+  );
+  console.log();
+}
+
+async function disconnectInteractive() {
+  const connections = getStoredConnections();
+  const connectedIds = Object.keys(connections);
+
+  if (connectedIds.length === 0) {
+    console.log();
+    console.log(chalk.hex('#7a9fff')('  No active connections.'));
+    console.log(
+      chalk.dim(`  Run ${chalk.hex('#215ff6')('slashdev connect')} to add one.`)
+    );
+    console.log();
+    return;
+  }
+
+  const choices = [];
+
+  for (const id of connectedIds) {
+    const provider = getProvider(id);
+
+    if (provider?.multiple && Array.isArray(connections[id])) {
+      for (let i = 0; i < connections[id].length; i++) {
+        const entry = connections[id][i];
+        choices.push({
+          name: `${provider.name}: ${entry.name} (${entry.username}@${entry.host}:${entry.port})`,
+          value: { providerId: id, index: i },
+        });
+      }
+    } else {
+      const data = connections[id];
+      choices.push({
+        name: `${provider?.name || id}${data.username ? ` (${data.username})` : ''}`,
+        value: { providerId: id, index: null },
+      });
+    }
+  }
+
+  const { selected } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selected',
+      message: chalk.hex('#7a9fff')('Which connection do you want to remove?'),
+      choices,
+    },
+  ]);
+
+  if (selected.index !== null) {
+    const entries = connections[selected.providerId];
+    const entry = entries[selected.index];
+    removeConnection(selected.providerId, selected.index);
+    console.log();
+    console.log(
+      chalk.hex('#4d7fff')(`  Removed server ${chalk.bold(entry.name)}.`)
+    );
+    console.log();
+  } else {
+    await disconnect(selected.providerId);
+  }
+}
+
+export function listConnections() {
+  const providers = getAllProviders();
+  const stored = getStoredConnections();
+
+  console.log();
+  console.log(chalk.hex('#215ff6').bold('  Connections'));
+  console.log(chalk.hex('#4d7fff')('  ─────────────────────────────────────────'));
+  console.log();
+
+  for (const [id, provider] of Object.entries(providers)) {
+    const conn = stored[id];
+
+    console.log(`    ${chalk.hex('#4d7fff')('◈')} ${chalk.hex('#215ff6').bold(provider.name)}`);
+    console.log(`      ${chalk.dim(provider.description)}`);
+
+    if (provider.multiple) {
+      if (Array.isArray(conn) && conn.length > 0) {
+        console.log(
+          `      ${chalk.hex('#4d7fff')('●')} ${conn.length} server${conn.length > 1 ? 's' : ''} connected`
+        );
+        for (const entry of conn) {
+          const authInfo = entry.authType === 'key' ? 'key' : 'password';
+          console.log(
+            chalk.dim(
+              `        - ${entry.name}: ${entry.username}@${entry.host}:${entry.port} (${authInfo})`
+            )
+          );
+        }
+      } else {
+        console.log(`      ${chalk.dim('○ No servers configured')}`);
+      }
+    } else {
+      const status = conn
+        ? chalk.hex('#4d7fff')('● Connected') +
+          (conn.username ? chalk.dim(` as ${conn.username}`) : '')
+        : chalk.dim('○ Not connected');
+      console.log(`      ${status}`);
+    }
+
+    console.log();
+  }
+}

package/src/connections/providers/github.js

@@ -0,0 +1,71 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { Octokit } from '@octokit/rest';
+
+export const githubProvider = {
+  id: 'github',
+  name: 'GitHub',
+  description: 'Access repositories, issues, and pull requests',
+  tokenUrl: 'https://github.com/settings/tokens',
+  requiredScopes: ['repo', 'read:user'],
+
+  async promptForCredentials() {
+    console.log();
+    console.log(chalk.dim('  Create a personal access token at:'));
+    console.log(
+      chalk.dim('  ') +
+        chalk.hex('#215ff6').underline('https://github.com/settings/tokens')
+    );
+    console.log(
+      chalk.dim('  Required scopes: ') +
+        chalk.hex('#7a9fff')('repo, read:user')
+    );
+    console.log();
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'password',
+        name: 'token',
+        message: chalk.hex('#7a9fff')('Enter your GitHub personal access token:'),
+        mask: '*',
+        validate: (input) => {
+          if (!input || input.trim().length === 0) {
+            return 'Token is required';
+          }
+          const trimmed = input.trim();
+          if (
+            !trimmed.startsWith('ghp_') &&
+            !trimmed.startsWith('github_pat_') &&
+            !trimmed.startsWith('gho_') &&
+            !trimmed.startsWith('ghu_')
+          ) {
+            return 'Invalid token format. GitHub tokens start with ghp_, github_pat_, gho_, or ghu_';
+          }
+          return true;
+        },
+      },
+    ]);
+
+    return { token: answers.token.trim() };
+  },
+
+  async validate(credentials) {
+    try {
+      const octokit = new Octokit({ auth: credentials.token });
+      const { data } = await octokit.rest.users.getAuthenticated();
+      return { valid: true, username: data.login };
+    } catch (error) {
+      return {
+        valid: false,
+        error:
+          error.status === 401
+            ? 'Invalid token. Please check and try again.'
+            : `GitHub API error: ${error.message}`,
+      };
+    }
+  },
+
+  createClient(credentials) {
+    return new Octokit({ auth: credentials.token });
+  },
+};