slashdev 0.1.0 → 1.0.0

package/src/skills/index.js

@@ -0,0 +1,252 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { isAuthenticated } from '../core/config.js';
+import { chat } from '../core/claude.js';
+import { getProjectContext, listFiles, readFile, getFrontendFiles } from '../core/codebase.js';
+import { isConnected, getConnection } from '../connections/index.js';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Built-in skills registry
+const SKILLS = {
+  'front-end-design': {
+    name: 'Front-end Design',
+    description: 'Expert UI/UX design assistance',
+    commands: ['design', 'ui', 'ux'],
+    promptFile: '../../skills/front-end-design/prompts/system.md',
+  },
+  'product-expert': {
+    name: 'Product Expert',
+    description: 'Product management and specifications',
+    commands: ['product', 'prd', 'spec'],
+    promptFile: '../../skills/product-expert/prompts/system.md',
+  },
+  'github-manager': {
+    name: 'GitHub Manager',
+    description: 'GitHub workflows and PR management',
+    commands: ['github', 'gh', 'pr'],
+    promptFile: '../../skills/github-manager/prompts/system.md',
+    requiredConnections: ['github'],
+  },
+  'front-end-testing': {
+    name: 'Front-end Testing',
+    description: 'Test generation and coverage analysis',
+    commands: ['test', 'testing', 'jest'],
+    promptFile: '../../skills/front-end-testing/prompts/system.md',
+  },
+  'server-admin': {
+    name: 'Server Admin',
+    description: 'AI-assisted server administration',
+    commands: ['server', 'ssh', 'admin'],
+    promptFile: '../../skills/server-admin/prompts/system.md',
+    requiredConnections: ['servers'],
+  },
+};
+
+export function listSkills() {
+  console.log();
+  console.log(chalk.hex('#215ff6').bold('  Installed Skills'));
+  console.log(chalk.hex('#4d7fff')('  ─────────────────────────────────────────'));
+  console.log();
+
+  for (const [id, skill] of Object.entries(SKILLS)) {
+    const commands = skill.commands.map(c => `slashdev ${c}`).join(', ');
+    console.log(`    ${chalk.hex('#4d7fff')('◈')} ${chalk.hex('#215ff6').bold(skill.name)}`);
+    console.log(`      ${chalk.dim(skill.description)}`);
+    console.log(`      ${chalk.dim('Commands:')} ${chalk.hex('#7a9fff')(commands)}`);
+    console.log();
+  }
+}
+
+export function getSkillByCommand(command) {
+  for (const [id, skill] of Object.entries(SKILLS)) {
+    if (skill.commands.includes(command)) {
+      return { id, ...skill };
+    }
+  }
+  return null;
+}
+
+export async function runSkill(skillId, prompt, options = {}) {
+  const skill = SKILLS[skillId];
+  if (!skill) {
+    console.log(chalk.red(`  Unknown skill: ${skillId}`));
+    return;
+  }
+
+  if (!isAuthenticated()) {
+    console.log();
+    console.log(chalk.hex('#7a9fff')('  You need to login first.'));
+    console.log(chalk.dim(`  Run ${chalk.hex('#215ff6')('slashdev login')} to authenticate.`));
+    console.log();
+    return;
+  }
+
+  if (skill.requiredConnections) {
+    for (const connId of skill.requiredConnections) {
+      if (!isConnected(connId)) {
+        console.log();
+        console.log(
+          chalk.hex('#7a9fff')(
+            `  This skill requires a ${connId} connection.`
+          )
+        );
+        console.log(
+          chalk.dim(
+            `  Run ${chalk.hex('#215ff6')(`slashdev connect ${connId}`)} to set it up.`
+          )
+        );
+        console.log();
+        return;
+      }
+    }
+  }
+
+  const cwd = process.cwd();
+  const projectContext = getProjectContext(cwd);
+
+  // Load system prompt
+  let systemPrompt = '';
+  try {
+    const promptPath = join(__dirname, skill.promptFile);
+    systemPrompt = readFile(promptPath);
+  } catch (e) {
+    // Use default if file doesn't exist
+    systemPrompt = getDefaultPrompt(skillId);
+  }
+
+  // Add project context to system prompt
+  systemPrompt += `\n\n## Current Project Context\n`;
+  systemPrompt += `- Framework: ${projectContext.framework}\n`;
+  systemPrompt += `- Has TypeScript: ${projectContext.hasTsConfig}\n`;
+  systemPrompt += `- Working Directory: ${cwd}\n`;
+
+  // Add connected services context
+  if (skill.requiredConnections) {
+    systemPrompt += `\n## Connected Services\n`;
+    for (const connId of skill.requiredConnections) {
+      const conn = getConnection(connId);
+      if (conn) {
+        if (Array.isArray(conn)) {
+          systemPrompt += `- ${connId}: ${conn.length} server(s) configured\n`;
+          for (const entry of conn) {
+            systemPrompt += `  - ${entry.name}: ${entry.username}@${entry.host}:${entry.port} (auth: ${entry.authType})\n`;
+          }
+        } else {
+          systemPrompt += `- ${connId}: connected as ${conn.username}\n`;
+        }
+      }
+    }
+  }
+
+  // Get relevant files based on skill
+  if (skillId === 'front-end-design' || skillId === 'front-end-testing') {
+    const files = getFrontendFiles(cwd).slice(0, 5);
+    if (files.length > 0) {
+      systemPrompt += `\n## Relevant Files\n`;
+      for (const file of files) {
+        systemPrompt += `- ${file.relativePath}\n`;
+      }
+    }
+  }
+
+  console.log();
+  console.log(chalk.hex('#215ff6').bold(`  ${skill.name}`));
+  console.log(chalk.hex('#4d7fff')('  ─────────────────────────────────────────'));
+  console.log();
+
+  const spinner = ora({
+    text: chalk.hex('#4d7fff')('Thinking...'),
+    color: 'blue',
+  }).start();
+
+  try {
+    let response = '';
+
+    if (options.stream !== false) {
+      spinner.stop();
+      process.stdout.write(chalk.hex('#7a9fff')('  '));
+
+      response = await chat({
+        messages: [{ role: 'user', content: prompt }],
+        systemPrompt,
+        stream: true,
+        onStream: (text) => {
+          process.stdout.write(chalk.hex('#a6bfff')(text));
+        },
+      });
+
+      console.log('\n');
+    } else {
+      response = await chat({
+        messages: [{ role: 'user', content: prompt }],
+        systemPrompt,
+      });
+      spinner.stop();
+      console.log(chalk.hex('#a6bfff')(`  ${response}`));
+      console.log();
+    }
+
+    return response;
+  } catch (error) {
+    spinner.fail(chalk.red(`Error: ${error.message}`));
+  }
+}
+
+function getDefaultPrompt(skillId) {
+  const prompts = {
+    'front-end-design': `You are a senior front-end design expert. You help with:
+- UI/UX design decisions
+- Component architecture
+- CSS and styling best practices
+- Accessibility (WCAG compliance)
+- Responsive design
+- Design systems
+
+Provide clear, actionable advice. Use code examples when helpful.`,
+
+    'product-expert': `You are a senior product manager. You help with:
+- Writing PRDs (Product Requirements Documents)
+- Creating user stories with acceptance criteria
+- Feature specifications
+- Roadmap planning
+- Stakeholder communication
+
+Be thorough but concise. Focus on clarity and actionability.`,
+
+    'github-manager': `You are a GitHub workflow expert. You help with:
+- Creating well-structured PRs
+- Writing clear commit messages
+- Issue management and triage
+- Release notes and changelogs
+- Branch strategies
+- Code review best practices
+
+Provide practical, ready-to-use suggestions.`,
+
+    'front-end-testing': `You are a front-end testing expert. You help with:
+- Writing unit tests (Jest, Vitest)
+- E2E tests (Playwright, Cypress)
+- Component testing (Testing Library)
+- Test coverage analysis
+- Mock and stub strategies
+- Testing best practices
+
+Always provide complete, runnable test code.`,
+
+    'server-admin': `You are an expert Linux server administrator. You help with:
+- System administration and service management
+- Security hardening and firewall configuration
+- Web server setup (Nginx, Apache, Caddy)
+- Database administration
+- Docker and container management
+- Monitoring, networking, and deployment
+
+Always warn about destructive commands and suggest backups before changes.`,
+  };
+
+  return prompts[skillId] || 'You are a helpful assistant.';
+}

package/src/utils/ssh-keys.js

@@ -0,0 +1,67 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, readdirSync } from 'fs';
+
+const KNOWN_KEY_NAMES = [
+  'id_rsa',
+  'id_ed25519',
+  'id_ecdsa',
+  'id_dsa',
+  'id_ed25519_sk',
+  'id_ecdsa_sk',
+];
+
+/**
+ * Scans ~/.ssh/ for SSH key pairs.
+ * Works on Linux, macOS, and Windows (all use os.homedir() + '.ssh').
+ * @returns {Array<{ name: string, privatePath: string, hasPublic: boolean }>}
+ */
+export function detectSSHKeys() {
+  const sshDir = join(homedir(), '.ssh');
+
+  if (!existsSync(sshDir)) {
+    return [];
+  }
+
+  let entries;
+  try {
+    entries = readdirSync(sshDir);
+  } catch {
+    return [];
+  }
+
+  const keys = [];
+
+  // Check known key names first
+  for (const name of KNOWN_KEY_NAMES) {
+    const privatePath = join(sshDir, name);
+    const publicPath = join(sshDir, `${name}.pub`);
+
+    if (existsSync(privatePath)) {
+      keys.push({
+        name,
+        privatePath,
+        hasPublic: existsSync(publicPath),
+      });
+    }
+  }
+
+  // Discover custom keys via .pub file matching
+  for (const entry of entries) {
+    if (entry.endsWith('.pub')) {
+      const baseName = entry.slice(0, -4);
+      if (!KNOWN_KEY_NAMES.includes(baseName)) {
+        const privatePath = join(sshDir, baseName);
+        if (existsSync(privatePath)) {
+          keys.push({
+            name: baseName,
+            privatePath,
+            hasPublic: true,
+          });
+        }
+      }
+    }
+  }
+
+  return keys;
+}

package/vendor/gstack/.env.example

@@ -0,0 +1,5 @@
+# Copy to .env and fill in values
+# bun auto-loads .env — no dotenv needed
+
+# Required for LLM-as-judge evals (bun run test:eval)
+ANTHROPIC_API_KEY=sk-ant-your-key-here