slashdev 0.1.0 → 1.0.0

package/src/connections/providers/servers.js

@@ -0,0 +1,175 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { userInfo } from 'os';
+import { detectSSHKeys } from '../../utils/ssh-keys.js';
+
+export const serversProvider = {
+  id: 'servers',
+  name: 'Servers',
+  description: 'SSH server connections for server administration',
+  multiple: true,
+
+  async promptForCredentials() {
+    console.log();
+    console.log(chalk.dim('  Add a server connection for AI-assisted administration.'));
+    console.log(chalk.dim('  The server does not need to be reachable right now.'));
+    console.log();
+
+    const currentUser = userInfo().username;
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: chalk.hex('#7a9fff')('Server alias (e.g. prod-web, staging-db):'),
+        validate: (input) => {
+          if (!input || input.trim().length === 0) {
+            return 'Server alias is required';
+          }
+          if (!/^[a-zA-Z0-9_-]+$/.test(input.trim())) {
+            return 'Alias must be alphanumeric (hyphens and underscores allowed)';
+          }
+          return true;
+        },
+      },
+      {
+        type: 'input',
+        name: 'host',
+        message: chalk.hex('#7a9fff')('Host or IP address:'),
+        validate: (input) => {
+          if (!input || input.trim().length === 0) {
+            return 'Host is required';
+          }
+          return true;
+        },
+      },
+      {
+        type: 'input',
+        name: 'port',
+        message: chalk.hex('#7a9fff')('SSH port:'),
+        default: '22',
+        validate: (input) => {
+          const port = parseInt(input, 10);
+          if (isNaN(port) || port < 1 || port > 65535) {
+            return 'Port must be a number between 1 and 65535';
+          }
+          return true;
+        },
+      },
+      {
+        type: 'input',
+        name: 'username',
+        message: chalk.hex('#7a9fff')('SSH username:'),
+        default: currentUser,
+        validate: (input) => {
+          if (!input || input.trim().length === 0) {
+            return 'Username is required';
+          }
+          return true;
+        },
+      },
+      {
+        type: 'list',
+        name: 'authType',
+        message: chalk.hex('#7a9fff')('Authentication method:'),
+        choices: [
+          { name: 'SSH Key', value: 'key' },
+          { name: 'Password', value: 'password' },
+        ],
+      },
+    ]);
+
+    const creds = {
+      name: answers.name.trim(),
+      host: answers.host.trim(),
+      port: parseInt(answers.port, 10),
+      username: answers.username.trim(),
+      authType: answers.authType,
+    };
+
+    if (answers.authType === 'key') {
+      const detectedKeys = detectSSHKeys();
+
+      const keyChoices = detectedKeys.map((k) => ({
+        name: `${k.name} (${k.privatePath})`,
+        value: k.privatePath,
+      }));
+      keyChoices.push({ name: 'Enter custom path...', value: '__custom__' });
+
+      if (detectedKeys.length > 0) {
+        const { keyPath } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'keyPath',
+            message: chalk.hex('#7a9fff')('Select SSH key:'),
+            choices: keyChoices,
+          },
+        ]);
+
+        if (keyPath === '__custom__') {
+          const { customPath } = await inquirer.prompt([
+            {
+              type: 'input',
+              name: 'customPath',
+              message: chalk.hex('#7a9fff')('Path to private key:'),
+              validate: (input) => {
+                if (!input || input.trim().length === 0) {
+                  return 'Key path is required';
+                }
+                return true;
+              },
+            },
+          ]);
+          creds.keyPath = customPath.trim();
+        } else {
+          creds.keyPath = keyPath;
+        }
+      } else {
+        console.log(chalk.dim('  No SSH keys detected in ~/.ssh/'));
+        const { customPath } = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'customPath',
+            message: chalk.hex('#7a9fff')('Path to private key:'),
+            validate: (input) => {
+              if (!input || input.trim().length === 0) {
+                return 'Key path is required';
+              }
+              return true;
+            },
+          },
+        ]);
+        creds.keyPath = customPath.trim();
+      }
+    } else {
+      const { password } = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'password',
+          message: chalk.hex('#7a9fff')('SSH password:'),
+          mask: '*',
+          validate: (input) => {
+            if (!input || input.trim().length === 0) {
+              return 'Password is required';
+            }
+            return true;
+          },
+        },
+      ]);
+      creds.password = password;
+    }
+
+    return creds;
+  },
+
+  async validate(credentials) {
+    return {
+      valid: true,
+      username: `${credentials.name} (${credentials.username}@${credentials.host}:${credentials.port})`,
+    };
+  },
+
+  createClient() {
+    return null;
+  },
+};

package/src/connections/registry.js

@@ -0,0 +1,21 @@
+import { githubProvider } from './providers/github.js';
+import { serversProvider } from './providers/servers.js';
+
+const CONNECTION_PROVIDERS = {
+  github: githubProvider,
+  servers: serversProvider,
+};
+
+export function getProvider(id) {
+  return CONNECTION_PROVIDERS[id] || null;
+}
+
+export function getAllProviders() {
+  return { ...CONNECTION_PROVIDERS };
+}
+
+export function getProviderIds() {
+  return Object.keys(CONNECTION_PROVIDERS);
+}
+
+export { CONNECTION_PROVIDERS };

package/src/core/claude.js

@@ -0,0 +1,78 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { getApiKey } from './config.js';
+import chalk from 'chalk';
+
+let client = null;
+
+export function getClient() {
+  const apiKey = getApiKey();
+
+  if (!apiKey) {
+    throw new Error('Not authenticated. Run `slashdev login` first.');
+  }
+
+  if (!client) {
+    client = new Anthropic({ apiKey });
+  }
+
+  return client;
+}
+
+export async function chat(options) {
+  const {
+    messages,
+    systemPrompt,
+    model = 'claude-sonnet-4-20250514',
+    maxTokens = 4096,
+    stream = false,
+    onStream = null,
+  } = options;
+
+  const client = getClient();
+
+  const requestOptions = {
+    model,
+    max_tokens: maxTokens,
+    messages,
+  };
+
+  if (systemPrompt) {
+    requestOptions.system = systemPrompt;
+  }
+
+  if (stream && onStream) {
+    // Streaming response
+    const response = await client.messages.create({
+      ...requestOptions,
+      stream: true,
+    });
+
+    let fullText = '';
+    for await (const event of response) {
+      if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
+        const text = event.delta.text;
+        fullText += text;
+        onStream(text);
+      }
+    }
+    return fullText;
+  } else {
+    // Non-streaming response
+    const response = await client.messages.create(requestOptions);
+    return response.content[0].text;
+  }
+}
+
+export async function validateApiKey(apiKey) {
+  try {
+    const testClient = new Anthropic({ apiKey });
+    await testClient.messages.create({
+      model: 'claude-sonnet-4-20250514',
+      max_tokens: 10,
+      messages: [{ role: 'user', content: 'Hi' }],
+    });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}

package/src/core/codebase.js

@@ -0,0 +1,119 @@
+import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
+import { join, relative, extname } from 'path';
+
+// Common file extensions for different categories
+const FILE_TYPES = {
+  frontend: ['.tsx', '.jsx', '.ts', '.js', '.vue', '.svelte', '.css', '.scss', '.sass', '.less', '.html'],
+  test: ['.test.ts', '.test.tsx', '.test.js', '.test.jsx', '.spec.ts', '.spec.tsx', '.spec.js', '.spec.jsx'],
+  config: ['.json', '.yaml', '.yml', '.toml', '.env'],
+  docs: ['.md', '.mdx', '.txt', '.rst'],
+};
+
+// Directories to ignore
+const IGNORE_DIRS = ['node_modules', '.git', 'dist', 'build', '.next', '.nuxt', 'coverage', '.cache'];
+
+export function readFile(filePath) {
+  try {
+    return readFileSync(filePath, 'utf-8');
+  } catch (error) {
+    throw new Error(`Could not read file: ${filePath}`);
+  }
+}
+
+export function fileExists(filePath) {
+  return existsSync(filePath);
+}
+
+export function listFiles(dir, options = {}) {
+  const {
+    recursive = true,
+    extensions = null,
+    ignore = IGNORE_DIRS,
+  } = options;
+
+  const files = [];
+
+  function walk(currentDir) {
+    const entries = readdirSync(currentDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      const relativePath = relative(dir, fullPath);
+
+      if (entry.isDirectory()) {
+        if (!ignore.includes(entry.name) && recursive) {
+          walk(fullPath);
+        }
+      } else {
+        if (!extensions || extensions.includes(extname(entry.name))) {
+          files.push({
+            path: fullPath,
+            relativePath,
+            name: entry.name,
+            ext: extname(entry.name),
+          });
+        }
+      }
+    }
+  }
+
+  walk(dir);
+  return files;
+}
+
+export function getFrontendFiles(dir) {
+  return listFiles(dir, { extensions: FILE_TYPES.frontend });
+}
+
+export function getTestFiles(dir) {
+  return listFiles(dir, { extensions: FILE_TYPES.test });
+}
+
+export function getProjectContext(dir) {
+  const context = {
+    hasPackageJson: fileExists(join(dir, 'package.json')),
+    hasTsConfig: fileExists(join(dir, 'tsconfig.json')),
+    hasVite: fileExists(join(dir, 'vite.config.ts')) || fileExists(join(dir, 'vite.config.js')),
+    hasNext: fileExists(join(dir, 'next.config.js')) || fileExists(join(dir, 'next.config.mjs')),
+    hasReact: false,
+    hasVue: false,
+    hasSvelte: false,
+    framework: 'unknown',
+  };
+
+  if (context.hasPackageJson) {
+    try {
+      const pkg = JSON.parse(readFile(join(dir, 'package.json')));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+      context.hasReact = 'react' in deps;
+      context.hasVue = 'vue' in deps;
+      context.hasSvelte = 'svelte' in deps;
+
+      if (context.hasNext) context.framework = 'Next.js';
+      else if (context.hasReact) context.framework = 'React';
+      else if (context.hasVue) context.framework = 'Vue';
+      else if (context.hasSvelte) context.framework = 'Svelte';
+    } catch (e) {
+      // Ignore parsing errors
+    }
+  }
+
+  return context;
+}
+
+export function buildFileContext(files, maxFiles = 10) {
+  const selected = files.slice(0, maxFiles);
+  let context = '';
+
+  for (const file of selected) {
+    try {
+      const content = readFile(file.path);
+      context += `\n--- ${file.relativePath} ---\n${content}\n`;
+    } catch (e) {
+      // Skip unreadable files
+    }
+  }
+
+  return context;
+}

package/src/core/config.js

@@ -0,0 +1,110 @@
+import Conf from 'conf';
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, mkdirSync } from 'fs';
+
+// Slashdev config directory
+const SLASHDEV_DIR = join(homedir(), '.slashdev');
+
+// Ensure the directory exists
+if (!existsSync(SLASHDEV_DIR)) {
+  mkdirSync(SLASHDEV_DIR, { recursive: true });
+}
+
+// Main configuration store
+const config = new Conf({
+  projectName: 'slashdev',
+  cwd: SLASHDEV_DIR,
+  configName: 'config',
+  defaults: {
+    version: '0.2.0',
+    skills: {
+      installed: ['front-end-design', 'product-expert', 'github-manager', 'front-end-testing'],
+    },
+  },
+});
+
+// Credentials store (separate for security)
+const credentials = new Conf({
+  projectName: 'slashdev',
+  cwd: SLASHDEV_DIR,
+  configName: 'credentials',
+  defaults: {
+    apiKey: null,
+    user: null,
+    connections: {},
+  },
+});
+
+export function getSlashdevDir() {
+  return SLASHDEV_DIR;
+}
+
+export function getConfig(key) {
+  return key ? config.get(key) : config.store;
+}
+
+export function setConfig(key, value) {
+  config.set(key, value);
+}
+
+export function getApiKey() {
+  return credentials.get('apiKey');
+}
+
+export function setApiKey(apiKey) {
+  credentials.set('apiKey', apiKey);
+}
+
+export function clearApiKey() {
+  credentials.delete('apiKey');
+  credentials.delete('user');
+}
+
+export function getUser() {
+  return credentials.get('user');
+}
+
+export function setUser(user) {
+  credentials.set('user', user);
+}
+
+export function isAuthenticated() {
+  return !!getApiKey();
+}
+
+// Engineer email (for Claude Code integration / logging)
+export function getEngineer() {
+  return config.get('engineer') || null;
+}
+
+export function setEngineer(email) {
+  config.set('engineer', email);
+}
+
+export function getPackageVersion() {
+  return config.get('packageVersion') || null;
+}
+
+export function getConnection(providerId) {
+  const connections = credentials.get('connections') || {};
+  return connections[providerId] || null;
+}
+
+export function setConnection(providerId, data) {
+  const connections = credentials.get('connections') || {};
+  connections[providerId] = data;
+  credentials.set('connections', connections);
+}
+
+export function clearConnection(providerId) {
+  const connections = credentials.get('connections') || {};
+  delete connections[providerId];
+  credentials.set('connections', connections);
+}
+
+export function getAllConnections() {
+  return credentials.get('connections') || {};
+}
+
+export { config, credentials };

package/src/index.js

@@ -2,5 +2,12 @@
 // Skills & workflows for AI agents in the Slashdev ecosystem
 
 export { run } from './cli.js';
-export { displayBanner, generateBanner, colorize } from './banner.js';
+export { displayBanner } from './banner.js';
 export { getPackageInfo, displayInfo, displayVersion, displayHelp } from './info.js';
+export { login, logout, whoami } from './auth/index.js';
+export { listSkills, runSkill, getSkillByCommand } from './skills/index.js';
+export { getConfig, setConfig, getApiKey, isAuthenticated, getEngineer, setEngineer } from './core/config.js';
+export { chat, getClient } from './core/claude.js';
+export { connect, disconnect, listConnections, isConnected, getConnection, getConnectionClient } from './connections/index.js';
+export { setup } from './commands/setup.js';
+export { update } from './commands/update.js';

package/src/info.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
+import { isAuthenticated, getUser } from './core/config.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -32,9 +33,19 @@ export function getPackageInfo() {
 export function displayInfo() {
   const pkg = getPackageInfo();
   const dim = chalk.dim;
+  const authed = isAuthenticated();
+  const user = getUser();
 
   console.log();
   console.log(`  ${blue.brand.bold(pkg.name)} ${dim('v' + pkg.version)}`);
+
+  // Auth status
+  if (authed) {
+    console.log(`  ${chalk.hex('#4d7fff')('●')} ${dim('Logged in' + (user ? ` as ${user}` : ''))}`);
+  } else {
+    console.log(`  ${dim('○ Not logged in — run')} ${blue.bright('slashdev login')}`);
+  }
+
   console.log();
 
   // Main value proposition
@@ -43,27 +54,28 @@ export function displayInfo() {
   console.log(`  ${blue.light('the Slashdev engineering team.')}`);
   console.log();
 
-  console.log(`  ${blue.brand.bold('What we do')}`);
+  console.log(`  ${blue.brand.bold('Skills')}`);
   console.log(`  ${blue.dark('────────────────────────────────────────────────────────')}`);
-  console.log(`    ${blue.bright('◈')} ${blue.soft('Skill Organization')}    ${dim('Structure and manage agent capabilities')}`);
-  console.log(`    ${blue.bright('◈')} ${blue.soft('Workflow Automation')}   ${dim('Streamline tasks with smart workflows')}`);
-  console.log(`    ${blue.bright('◈')} ${blue.soft('QA Processes')}          ${dim('Built-in quality assurance for outputs')}`);
-  console.log(`    ${blue.bright('◈')} ${blue.soft('Best Practices')}        ${dim('The Slashdev engineering playbook')}`);
+  console.log(`    ${blue.bright('slashdev design')} ${blue.soft('<prompt>')}    ${dim('UI/UX and component design')}`);
+  console.log(`    ${blue.bright('slashdev product')} ${blue.soft('<prompt>')}   ${dim('PRDs, specs, and user stories')}`);
+  console.log(`    ${blue.bright('slashdev github')} ${blue.soft('<prompt>')}    ${dim('PRs, issues, and releases')}`);
+  console.log(`    ${blue.bright('slashdev test')} ${blue.soft('<prompt>')}      ${dim('Unit and E2E test generation')}`);
+  console.log(`    ${blue.bright('slashdev server')} ${blue.soft('<prompt>')}    ${dim('Server administration')}`);
   console.log();
 
-  console.log(`  ${blue.brand.bold('Commands')}`);
+  console.log(`  ${blue.brand.bold('Account')}`);
   console.log(`  ${blue.dark('────────────────────────────────────────────────────────')}`);
-  console.log(`    ${blue.bright('slashdev')}              ${dim('Show this banner')}`);
-  console.log(`    ${blue.bright('slashdev --help')}       ${dim('Display help information')}`);
-  console.log(`    ${blue.bright('slashdev --version')}    ${dim('Show version number')}`);
+  console.log(`    ${blue.bright('slashdev login')}            ${dim('Authenticate with API key')}`);
+  console.log(`    ${blue.bright('slashdev logout')}           ${dim('Clear stored credentials')}`);
+  console.log(`    ${blue.bright('slashdev whoami')}           ${dim('Show auth status')}`);
+  console.log(`    ${blue.bright('slashdev skills')}           ${dim('List installed skills')}`);
   console.log();
 
-  console.log(`  ${blue.brand.bold('Coming Soon')}`);
+  console.log(`  ${blue.brand.bold('Connections')}`);
   console.log(`  ${blue.dark('────────────────────────────────────────────────────────')}`);
-  console.log(`    ${blue.bright('▸')} Agent skills & workflow library`);
-  console.log(`    ${blue.bright('▸')} MCP server integrations`);
-  console.log(`    ${blue.bright('▸')} Team collaboration tools`);
-  console.log(`    ${blue.bright('▸')} Slashdev skill marketplace`);
+  console.log(`    ${blue.bright('slashdev connect')} ${blue.soft('[service]')}  ${dim('Add a service connection')}`);
+  console.log(`    ${blue.bright('slashdev disconnect')} ${blue.soft('[service]')} ${dim('Remove a connection')}`);
+  console.log(`    ${blue.bright('slashdev connections')}       ${dim('List all connections')}`);
   console.log();
 
   console.log(`  ${dim('Learn more at')} ${blue.brand.underline('https://slashdev.io')}`);
@@ -79,16 +91,37 @@ export function displayHelp() {
   const dim = chalk.dim;
 
   console.log();
-  console.log(`  ${blue.brand.bold('Usage')} ${dim('slashdev [command] [options]')}`);
+  console.log(`  ${blue.brand.bold('Usage')} ${dim('slashdev <command> [options]')}`);
+  console.log();
+
+  console.log(`  ${blue.brand.bold('Skills')}`);
+  console.log(`  ${blue.dark('──────────────────────────────────────────')}`);
+  console.log(`    ${blue.bright('design <prompt>')}    ${dim('Front-end design help')}`);
+  console.log(`    ${blue.bright('product <prompt>')}   ${dim('Product management help')}`);
+  console.log(`    ${blue.bright('github <prompt>')}    ${dim('GitHub workflow help')}`);
+  console.log(`    ${blue.bright('test <prompt>')}      ${dim('Testing help')}`);
+  console.log(`    ${blue.bright('server <prompt>')}    ${dim('Server admin help')}`);
+  console.log();
+
+  console.log(`  ${blue.brand.bold('Account')}`);
+  console.log(`  ${blue.dark('──────────────────────────────────────────')}`);
+  console.log(`    ${blue.bright('login')}             ${dim('Authenticate')}`);
+  console.log(`    ${blue.bright('logout')}            ${dim('Sign out')}`);
+  console.log(`    ${blue.bright('whoami')}            ${dim('Check status')}`);
+  console.log(`    ${blue.bright('skills')}            ${dim('List skills')}`);
   console.log();
+
   console.log(`  ${blue.brand.bold('Options')}`);
-  console.log(`  ${blue.dark('──────────────────────────────')}`);
-  console.log(`    ${blue.bright('-h, --help')}       ${dim('Display this help message')}`);
-  console.log(`    ${blue.bright('-v, --version')}    ${dim('Display version number')}`);
+  console.log(`  ${blue.dark('──────────────────────────────────────────')}`);
+  console.log(`    ${blue.bright('-h, --help')}        ${dim('Show help')}`);
+  console.log(`    ${blue.bright('-v, --version')}     ${dim('Show version')}`);
   console.log();
+
   console.log(`  ${blue.brand.bold('Examples')}`);
-  console.log(`  ${blue.dark('──────────────────────────────')}`);
-  console.log(`    ${dim('$')} slashdev              ${dim('# Show banner and info')}`);
-  console.log(`    ${dim('$')} slashdev --version    ${dim('# Print version')}`);
+  console.log(`  ${blue.dark('──────────────────────────────────────────')}`);
+  console.log(`    ${dim('$')} slashdev login`);
+  console.log(`    ${dim('$')} slashdev design "review my Button component"`);
+  console.log(`    ${dim('$')} slashdev product "write a PRD for user auth"`);
+  console.log(`    ${dim('$')} slashdev test "generate tests for utils.ts"`);
   console.log();
 }