slashdev 0.1.0 → 1.1.0

package/src/auth/index.js

@@ -0,0 +1,115 @@
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import { setApiKey, setUser, getApiKey, getUser, clearApiKey, isAuthenticated } from '../core/config.js';
+import { validateApiKey } from '../core/claude.js';
+import { blue } from '../banner.js';
+
+export async function login() {
+  console.log();
+
+  if (isAuthenticated()) {
+    const user = getUser();
+    console.log(chalk.hex('#4d7fff')(`  You're already logged in${user ? ` as ${chalk.bold(user)}` : ''}.`));
+    console.log(chalk.dim(`  Run ${chalk.hex('#215ff6')('slashdev logout')} to sign out first.`));
+    console.log();
+    return;
+  }
+
+  console.log(chalk.hex('#215ff6').bold('  Slashdev Login'));
+  console.log(chalk.hex('#4d7fff')('  ─────────────────────────────────────────'));
+  console.log();
+  console.log(chalk.dim('  To use Slashdev skills, you need an Anthropic API key.'));
+  console.log(chalk.dim('  Get one at: ') + chalk.hex('#215ff6').underline('https://console.anthropic.com/settings/keys'));
+  console.log();
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'apiKey',
+      message: chalk.hex('#7a9fff')('Enter your Anthropic API key:'),
+      mask: '*',
+      validate: (input) => {
+        if (!input || input.trim().length === 0) {
+          return 'API key is required';
+        }
+        if (!input.startsWith('sk-ant-')) {
+          return 'Invalid API key format. Should start with sk-ant-';
+        }
+        return true;
+      },
+    },
+    {
+      type: 'input',
+      name: 'name',
+      message: chalk.hex('#7a9fff')('What should we call you? (optional):'),
+      default: '',
+    },
+  ]);
+
+  const spinner = ora({
+    text: chalk.hex('#4d7fff')('Validating API key...'),
+    color: 'blue',
+  }).start();
+
+  const isValid = await validateApiKey(answers.apiKey.trim());
+
+  if (!isValid) {
+    spinner.fail(chalk.red('Invalid API key. Please check and try again.'));
+    return;
+  }
+
+  setApiKey(answers.apiKey.trim());
+  if (answers.name) {
+    setUser(answers.name.trim());
+  }
+
+  spinner.succeed(chalk.hex('#4d7fff')('API key validated and saved!'));
+  console.log();
+  console.log(chalk.hex('#215ff6').bold(`  Welcome to Slashdev${answers.name ? `, ${answers.name}` : ''}!`));
+  console.log();
+  console.log(chalk.dim('  Try running a skill:'));
+  console.log(`    ${chalk.hex('#4d7fff')('slashdev design')} ${chalk.dim('"review my Button component"')}`);
+  console.log(`    ${chalk.hex('#4d7fff')('slashdev product')} ${chalk.dim('"write a PRD for user auth"')}`);
+  console.log();
+}
+
+export async function logout() {
+  console.log();
+
+  if (!isAuthenticated()) {
+    console.log(chalk.hex('#7a9fff')('  You\'re not logged in.'));
+    console.log();
+    return;
+  }
+
+  const user = getUser();
+  clearApiKey();
+
+  console.log(chalk.hex('#4d7fff')(`  Logged out${user ? ` ${user}` : ''} successfully.`));
+  console.log(chalk.dim(`  Run ${chalk.hex('#215ff6')('slashdev login')} to sign in again.`));
+  console.log();
+}
+
+export function whoami() {
+  console.log();
+
+  if (!isAuthenticated()) {
+    console.log(chalk.hex('#7a9fff')('  Not logged in.'));
+    console.log(chalk.dim(`  Run ${chalk.hex('#215ff6')('slashdev login')} to authenticate.`));
+    console.log();
+    return;
+  }
+
+  const user = getUser();
+  const apiKey = getApiKey();
+  const maskedKey = apiKey ? `${apiKey.slice(0, 10)}...${apiKey.slice(-4)}` : 'unknown';
+
+  console.log(chalk.hex('#215ff6').bold('  Slashdev Account'));
+  console.log(chalk.hex('#4d7fff')('  ─────────────────────────────────────────'));
+  console.log();
+  console.log(`    ${chalk.hex('#7a9fff')('User:')}     ${user || chalk.dim('(not set)')}`);
+  console.log(`    ${chalk.hex('#7a9fff')('API Key:')}  ${chalk.dim(maskedKey)}`);
+  console.log(`    ${chalk.hex('#7a9fff')('Status:')}   ${chalk.hex('#4d7fff')('● Authenticated')}`);
+  console.log();
+}

package/src/cli.js

@@ -1,23 +1,193 @@
+import { Command } from 'commander';
 import { displayBanner } from './banner.js';
 import { displayInfo, displayVersion, displayHelp } from './info.js';
+import { login, logout, whoami } from './auth/index.js';
+import { listSkills, runSkill, getSkillByCommand } from './skills/index.js';
+import { connect, disconnect, listConnections } from './connections/index.js';
+import { setup } from './commands/setup.js';
+import { update } from './commands/update.js';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+
+const program = new Command();
+
+program
+  .name('slashdev')
+  .description('Skills & workflows for AI agents in the Slashdev ecosystem')
+  .version(pkg.version, '-v, --version', 'Show version number');
+
+// Claude Code integration commands
+program
+  .command('setup')
+  .description('Install Claude Code hooks and skills for your Slashdev account')
+  .action(async () => {
+    displayBanner();
+    await setup();
+  });
+
+program
+  .command('update')
+  .description('Update Claude Code hooks and skills to the latest version')
+  .action(async () => {
+    displayBanner();
+    await update();
+  });
+
+// Default action (no command) - show banner
+program
+  .action(async () => {
+    displayBanner();
+    displayInfo();
+  });
+
+// Authentication commands
+program
+  .command('login')
+  .description('Authenticate with your Anthropic API key')
+  .action(async () => {
+    displayBanner();
+    await login();
+  });
+
+program
+  .command('logout')
+  .description('Clear stored credentials')
+  .action(async () => {
+    await logout();
+  });
+
+program
+  .command('whoami')
+  .description('Show current authentication status')
+  .action(() => {
+    whoami();
+  });
+
+// Connection commands
+program
+  .command('connect [service]')
+  .description('Connect an external service (e.g. github)')
+  .action(async (service) => {
+    displayBanner();
+    await connect(service);
+  });
+
+program
+  .command('disconnect [service]')
+  .description('Remove a connected service')
+  .action(async (service) => {
+    await disconnect(service);
+  });
+
+program
+  .command('connections')
+  .description('List all connections and their status')
+  .action(() => {
+    displayBanner();
+    listConnections();
+  });
+
+// Skills command
+program
+  .command('skills')
+  .description('List installed skills')
+  .action(() => {
+    displayBanner();
+    listSkills();
+  });
+
+// Design skill
+program
+  .command('design [prompt...]')
+  .description('Front-end design assistance')
+  .action(async (promptParts) => {
+    const prompt = promptParts.join(' ');
+    if (!prompt) {
+      console.log('\n  Usage: slashdev design "your design question"\n');
+      console.log('  Examples:');
+      console.log('    slashdev design "review my Button component for accessibility"');
+      console.log('    slashdev design "create a dark mode color palette"');
+      console.log('    slashdev design "improve the mobile layout"\n');
+      return;
+    }
+    await runSkill('front-end-design', prompt);
+  });
+
+// Product skill
+program
+  .command('product [prompt...]')
+  .description('Product management assistance')
+  .action(async (promptParts) => {
+    const prompt = promptParts.join(' ');
+    if (!prompt) {
+      console.log('\n  Usage: slashdev product "your product question"\n');
+      console.log('  Examples:');
+      console.log('    slashdev product "write a PRD for user authentication"');
+      console.log('    slashdev product "create user stories for checkout flow"');
+      console.log('    slashdev product "draft release notes for v2.0"\n');
+      return;
+    }
+    await runSkill('product-expert', prompt);
+  });
+
+// GitHub skill
+program
+  .command('github [prompt...]')
+  .alias('gh')
+  .description('GitHub workflow assistance')
+  .action(async (promptParts) => {
+    const prompt = promptParts.join(' ');
+    if (!prompt) {
+      console.log('\n  Usage: slashdev github "your github question"\n');
+      console.log('  Examples:');
+      console.log('    slashdev github "write a PR description for adding auth"');
+      console.log('    slashdev github "create release notes for v1.2.0"');
+      console.log('    slashdev github "structure an issue for a login bug"\n');
+      return;
+    }
+    await runSkill('github-manager', prompt);
+  });
+
+// Test skill
+program
+  .command('test [prompt...]')
+  .description('Front-end testing assistance')
+  .action(async (promptParts) => {
+    const prompt = promptParts.join(' ');
+    if (!prompt) {
+      console.log('\n  Usage: slashdev test "your testing question"\n');
+      console.log('  Examples:');
+      console.log('    slashdev test "write unit tests for the Button component"');
+      console.log('    slashdev test "create E2E tests for user login flow"');
+      console.log('    slashdev test "improve test coverage for the utils"\n');
+      return;
+    }
+    await runSkill('front-end-testing', prompt);
+  });
+
+// Server admin skill
+program
+  .command('server [prompt...]')
+  .alias('ssh')
+  .description('Server administration assistance')
+  .action(async (promptParts) => {
+    const prompt = promptParts.join(' ');
+    if (!prompt) {
+      console.log('\n  Usage: slashdev server "your server question"\n');
+      console.log('  Examples:');
+      console.log('    slashdev server "harden SSH config on prod-web"');
+      console.log('    slashdev server "set up nginx reverse proxy"');
+      console.log('    slashdev server "check disk usage and clean up"\n');
+      return;
+    }
+    await runSkill('server-admin', prompt);
+  });
 
 export async function run(args) {
-  const flags = new Set(args);
-
-  // Handle --version / -v
-  if (flags.has('--version') || flags.has('-v')) {
-    displayVersion();
-    return;
-  }
-
-  // Handle --help / -h
-  if (flags.has('--help') || flags.has('-h')) {
-    await displayBanner();
-    displayHelp();
-    return;
-  }
-
-  // Default: show banner + info
-  await displayBanner();
-  displayInfo();
+  await program.parseAsync(['node', 'slashdev', ...args]);
 }

package/src/commands/setup-internals.js

@@ -0,0 +1,221 @@
+// Shared install functions used by both setup and update commands
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  copyFileSync,
+  chmodSync,
+} from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PACKAGE_ROOT = join(__dirname, '..', '..');
+
+const CLAUDE_DIR = join(homedir(), '.claude');
+const CLAUDE_HOOKS_DIR = join(CLAUDE_DIR, 'hooks');
+const CLAUDE_SKILLS_DIR = join(CLAUDE_DIR, 'skills');
+const CLAUDE_SETTINGS_FILE = join(CLAUDE_DIR, 'settings.json');
+const CLAUDE_MEMORY_FILE = join(CLAUDE_DIR, 'CLAUDE.md');
+
+const SLASHDEV_SECTION_START = '<!-- SLASHDEV:RULES:START -->';
+const SLASHDEV_SECTION_END = '<!-- SLASHDEV:RULES:END -->';
+
+const SLASHDEV_RULES_BLOCK = `${SLASHDEV_SECTION_START}
+# Slashdev workspace rules
+
+## Security: always use Socket Firewall for dependency installs
+
+Claude must use Socket Firewall (\`sfw\`) for **every** dependency install command.
+This applies to:
+
+- **Local development** — never run \`npm install\`, \`pnpm install\`, \`yarn add\`,
+  \`bun install\`, \`composer install\`, \`pip install\`, or any equivalent without
+  prefixing \`sfw \`. A PreToolUse hook will block bare install commands and tell
+  you to retry with \`sfw\`.
+- **Production deployment** — when generating or editing CI/CD config (GitHub Actions,
+  GitLab CI, CircleCI, Jenkins), Dockerfiles, deploy scripts (\`deploy.sh\`, \`Procfile\`),
+  or \`package.json\` scripts that install dependencies, **always** wrap the install
+  step with \`sfw\`. Examples:
+  - \`sfw npm ci\` instead of \`npm ci\`
+  - \`sfw composer install --no-dev\` instead of \`composer install --no-dev\`
+  - \`RUN npm install -g @socketsecurity/cli && sfw npm ci\` in a Dockerfile
+- If \`sfw\` is not yet installed in a CI environment, install it first:
+  \`npm install -g @socketsecurity/cli\`. Document the install step inline in the workflow.
+- Use the \`/secure-deploy\` skill to retrofit existing CI/CD configs.
+
+Reason: Socket Firewall scans every package against Socket's vulnerability/malware
+database before letting it install. This protects against supply-chain attacks
+(compromised packages, typosquats, dependency confusion).
+${SLASHDEV_SECTION_END}`;
+
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+function copyDirRecursive(src, dest) {
+  ensureDir(dest);
+  const entries = readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+      if (entry.name.endsWith('.sh')) {
+        chmodSync(destPath, 0o755);
+      }
+    }
+  }
+}
+
+export function installHooks() {
+  const hooksSource = join(PACKAGE_ROOT, 'hooks');
+  if (!existsSync(hooksSource)) {
+    return { installed: 0 };
+  }
+
+  ensureDir(CLAUDE_HOOKS_DIR);
+  copyDirRecursive(hooksSource, CLAUDE_HOOKS_DIR);
+
+  // Register hooks in Claude Code settings.json
+  let settings = {};
+  if (existsSync(CLAUDE_SETTINGS_FILE)) {
+    try {
+      settings = JSON.parse(readFileSync(CLAUDE_SETTINGS_FILE, 'utf-8'));
+    } catch {
+      settings = {};
+    }
+  }
+
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  const hookCommand = join(CLAUDE_HOOKS_DIR, 'post-response.sh');
+  const stopHooks = settings.hooks.Stop || [];
+
+  const alreadyRegistered = stopHooks.some(
+    (h) => h.hooks && h.hooks.some((inner) => inner.command && inner.command.includes('post-response.sh'))
+  );
+
+  if (!alreadyRegistered) {
+    stopHooks.push({
+      matcher: '',
+      hooks: [
+        {
+          type: 'command',
+          command: hookCommand,
+        },
+      ],
+    });
+    settings.hooks.Stop = stopHooks;
+  }
+
+  // Register PreToolUse hook for the install guard (Bash tool only).
+  const guardCommand = join(CLAUDE_HOOKS_DIR, 'pre-install-guard.sh');
+  if (existsSync(guardCommand)) {
+    const preToolUseHooks = settings.hooks.PreToolUse || [];
+    const guardRegistered = preToolUseHooks.some(
+      (entry) =>
+        entry.matcher === 'Bash' &&
+        Array.isArray(entry.hooks) &&
+        entry.hooks.some((h) => h.command && h.command.includes('pre-install-guard.sh'))
+    );
+
+    if (!guardRegistered) {
+      preToolUseHooks.push({
+        matcher: 'Bash',
+        hooks: [
+          {
+            type: 'command',
+            command: guardCommand,
+            statusMessage: 'Checking install safety…',
+          },
+        ],
+      });
+      settings.hooks.PreToolUse = preToolUseHooks;
+    }
+  }
+
+  writeFileSync(CLAUDE_SETTINGS_FILE, JSON.stringify(settings, null, 2), 'utf-8');
+
+  const hookFiles = readdirSync(hooksSource).filter((f) => f.endsWith('.sh'));
+  return { installed: hookFiles.length };
+}
+
+export function writeGlobalClaudeMd() {
+  ensureDir(CLAUDE_DIR);
+
+  let existing = '';
+  if (existsSync(CLAUDE_MEMORY_FILE)) {
+    existing = readFileSync(CLAUDE_MEMORY_FILE, 'utf-8');
+  }
+
+  let next;
+  if (existing.includes(SLASHDEV_SECTION_START) && existing.includes(SLASHDEV_SECTION_END)) {
+    // Replace the existing managed section in place, preserving everything around it.
+    const before = existing.split(SLASHDEV_SECTION_START)[0];
+    const after = existing.split(SLASHDEV_SECTION_END)[1];
+    next = `${before}${SLASHDEV_RULES_BLOCK}${after}`;
+  } else if (existing.trim().length > 0) {
+    // Append after existing user content.
+    next = `${existing.trimEnd()}\n\n${SLASHDEV_RULES_BLOCK}\n`;
+  } else {
+    // Brand new file.
+    next = `${SLASHDEV_RULES_BLOCK}\n`;
+  }
+
+  writeFileSync(CLAUDE_MEMORY_FILE, next, 'utf-8');
+  return { written: true, path: CLAUDE_MEMORY_FILE };
+}
+
+export function installSkills() {
+  const skillsSource = join(PACKAGE_ROOT, 'claude-skills');
+  if (!existsSync(skillsSource)) {
+    return { installed: 0 };
+  }
+
+  ensureDir(CLAUDE_SKILLS_DIR);
+
+  const skillDirs = readdirSync(skillsSource, { withFileTypes: true }).filter((d) => d.isDirectory());
+
+  for (const dir of skillDirs) {
+    const srcPath = join(skillsSource, dir.name);
+    const destPath = join(CLAUDE_SKILLS_DIR, dir.name);
+    copyDirRecursive(srcPath, destPath);
+  }
+
+  return { installed: skillDirs.length };
+}
+
+export function installGstack() {
+  const gstackSource = join(PACKAGE_ROOT, 'vendor', 'gstack');
+  if (!existsSync(gstackSource)) {
+    return { installed: 0, warning: 'gstack submodule not initialized. Run: git submodule update --init vendor/gstack' };
+  }
+
+  const gstackDest = join(CLAUDE_SKILLS_DIR, 'gstack');
+  ensureDir(gstackDest);
+
+  const entries = readdirSync(gstackSource, { withFileTypes: true }).filter((d) => d.isDirectory());
+  let installed = 0;
+
+  for (const dir of entries) {
+    const skillMd = join(gstackSource, dir.name, 'SKILL.md');
+    if (existsSync(skillMd)) {
+      const destPath = join(gstackDest, dir.name);
+      copyDirRecursive(join(gstackSource, dir.name), destPath);
+      installed++;
+    }
+  }
+
+  return { installed };
+}

package/src/commands/setup.js

@@ -0,0 +1,110 @@
+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, writeGlobalClaudeMd } 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();
+
+    // Write global Claude rules (Socket Firewall + workspace policy)
+    spinner.text = 'Writing global Claude rules...';
+    const rulesResult = writeGlobalClaudeMd();
+
+    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('✓')} Rules:     ${rulesResult.path}`);
+    console.log(`  ${chalk.green('✓')} Config:    ${join(getSlashdevDir(), 'config.json')}`);
+    console.log('');
+    console.log(chalk.dim('  Hooks, skills, and global rules have been installed to ~/.claude/'));
+    console.log(chalk.dim('  Socket Firewall enforcement is active for all Bash install commands.'));
+    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);
+  }
+}