kitstore-cli 1.0.0

package/src/commands/login.ts

@@ -0,0 +1,65 @@
+import inquirer from 'inquirer';
+import axios from 'axios';
+import { getConfig, saveConfig } from '../config';
+import { createApi } from '../api/client';
+
+/**
+ * @requirement TC-UNIT-CLI-001, TC-UNIT-CLI-002, TC-E2E-CLI-001
+ */
+export async function loginCommand(options: {
+  email?: string;
+  password?: string;
+  server?: string;
+}) {
+  try {
+    const config = await getConfig();
+    const server = options.server || config.server;
+
+    let email = options.email;
+    let password = options.password;
+
+    if (!email) {
+      const answer = await inquirer.prompt([
+        { type: 'input', name: 'email', message: 'Email:' }
+      ]);
+      email = answer.email;
+    }
+
+    if (!password) {
+      const answer = await inquirer.prompt([
+        { type: 'password', name: 'password', message: 'Password:' }
+      ]);
+      password = answer.password;
+    }
+
+    const { authApi } = await createApi({ server });
+    if (!email || !password) {
+      throw new Error('Email and password are required');
+    }
+    const response = await authApi.authControllerLogin({ email, password });
+    const data = response.data;
+
+    if ((data as any).token) {
+      await saveConfig({
+        token: (data as any).token,
+        server,
+        user: (data as any).user,
+        lastLogin: new Date().toISOString(),
+      });
+
+      console.log(`✅ Logged in as ${(data as any).user.username}`);
+    } else {
+      console.error('❌ Login failed');
+      process.exit(1);
+    }
+  } catch (err: unknown) {
+    if (axios.isAxiosError(err)) {
+      console.error(`❌ Login failed: ${err.response?.data?.error || err.message}`);
+    } else if (err instanceof Error) {
+      console.error(`❌ Login failed: ${err.message}`);
+    } else {
+      console.error(`❌ Login failed: ${err}`);
+    }
+    process.exit(1);
+  }
+}

package/src/commands/rule-check.ts

@@ -0,0 +1,49 @@
+import * as fs from 'fs-extra';
+import chalk from 'chalk';
+
+/**
+ * @requirement TC-UNIT-CLI-CHECK-001
+ */
+export async function ruleCheckCommand(filePath: string) {
+  try {
+    if (!(await fs.pathExists(filePath))) {
+      console.error(chalk.red(`❌ File not found: ${filePath}`));
+      process.exit(1);
+    }
+
+    const content = await fs.readFile(filePath, 'utf-8');
+    const lines = content.split('\n');
+    
+    let errors = 0;
+    let warnings = 0;
+
+    console.log(chalk.blue(`Checking rule: ${filePath}...`));
+
+    // Basic checks
+    if (content.length === 0) {
+      console.error(chalk.red('   - Error: File is empty'));
+      errors++;
+    }
+
+    if (!content.includes('@requirement')) {
+      console.warn(chalk.yellow('   - Warning: Missing @requirement tag'));
+      warnings++;
+    }
+
+    if (lines.length > 500) {
+      console.warn(chalk.yellow('   - Warning: File is very long (>500 lines)'));
+      warnings++;
+    }
+
+    if (errors === 0 && warnings === 0) {
+      console.log(chalk.green('✅ Rule validation passed!'));
+    } else {
+      console.log('');
+      console.log(`Validation finished with ${chalk.red(errors + ' errors')} and ${chalk.yellow(warnings + ' warnings')}.`);
+    }
+  } catch (err: any) {
+    console.error(chalk.red(`❌ Check failed: ${err.message}`));
+    process.exit(1);
+  }
+}
+

package/src/commands/search.ts

@@ -0,0 +1,66 @@
+import { getConfig } from '../config';
+import { createApi } from '../api/client';
+
+export async function searchCommand(
+  query: string,
+  options: {
+    type?: string;
+    tag?: string;
+    limit?: string;
+  }
+) {
+  try {
+    const config = await getConfig();
+
+    if (!config.token) {
+      console.error('❌ Not logged in. Please run `kitstore login` first.');
+      process.exit(1);
+    }
+
+    if (!query || query.trim() === '') {
+      console.error('❌ Search query is required.');
+      process.exit(1);
+    }
+
+    const { rulesApi } = await createApi({ server: config.server });
+
+    const queryParams: any = {
+      name: query, // Search by name using the name filter
+    };
+    if (options.type) queryParams.type = options.type;
+    if (options.tag) queryParams.tag = options.tag;
+    if (options.limit) queryParams.limit = parseInt(options.limit);
+
+    const response = await rulesApi.rulesControllerFindAll(queryParams);
+
+    if (response.data && response.data.length > 0) {
+      console.log(`🔍 Search results for "${query}":`);
+      console.log(`📋 Found ${response.data.length} matching rules/commands:`);
+      console.log('');
+
+      response.data.forEach((rule: any) => {
+        console.log(`📄 ${rule.name}`);
+        console.log(`   ID: ${rule.id}`);
+        console.log(`   Tag: ${rule.tag}`);
+        console.log(`   Type: ${rule.type}`);
+        console.log(`   Version: ${rule.version}`);
+        console.log(`   Author: ${rule.author.username}`);
+        if (rule.description) {
+          console.log(`   Description: ${rule.description}`);
+        }
+        console.log('');
+      });
+    } else {
+      console.log(`🔍 No rules or commands found matching "${query}".`);
+    }
+  } catch (err: unknown) {
+    if (err && typeof err === 'object' && 'response' in err) {
+      const axiosError = err as any;
+      console.error('❌ Search failed:', axiosError.response?.data?.error || axiosError.message);
+    } else {
+      console.error('❌ Search failed:', err);
+    }
+    process.exit(1);
+  }
+}
+

package/src/commands/upload.ts

@@ -0,0 +1,117 @@
+import axios from 'axios';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import FormData from 'form-data';
+import { getConfig } from '../config';
+
+/**
+ * @requirement TC-UNIT-CLI-004, TC-UNIT-CLI-005, TC-E2E-CLI-003
+ */
+export async function uploadCommand(
+  filePath: string,
+  options: {
+    name?: string;
+    tag?: string;
+    type?: string;
+    description?: string;
+    version?: string;
+  }
+) {
+  try {
+    const config = await getConfig();
+
+    if (!config.token) {
+      console.error('❌ Not logged in. Please run: kitstore login');
+      process.exit(1);
+    }
+
+    // Validate file exists
+    if (!(await fs.pathExists(filePath))) {
+      console.error(`❌ File not found: ${filePath}`);
+      process.exit(1);
+    }
+
+    // Validate file size (max 10MB)
+    const stats = await fs.stat(filePath);
+    const fileSizeInMB = stats.size / (1024 * 1024);
+    const maxSizeInMB = 10;
+    if (fileSizeInMB > maxSizeInMB) {
+      console.error(`❌ File size exceeds limit (${fileSizeInMB.toFixed(2)} MB > ${maxSizeInMB} MB)`);
+      process.exit(1);
+    }
+
+    // Validate file type
+    const allowedExtensions = ['.md', '.txt', '.json', '.cursorrules'];
+    const fileExtension = path.extname(filePath).toLowerCase();
+    if (!allowedExtensions.includes(fileExtension)) {
+      console.error(`❌ Invalid file type. Allowed types: ${allowedExtensions.join(', ')}`);
+      process.exit(1);
+    }
+
+    // Auto-detect type from path if not provided
+    let type = options.type;
+    if (!type) {
+      const normalizedPath = path.normalize(filePath);
+      if (normalizedPath.includes('.cursor/rules') || normalizedPath.includes('.cursorrules')) {
+        type = 'rule';
+      } else if (normalizedPath.includes('.cursor/commands')) {
+        type = 'command';
+      }
+    }
+
+    if (!type) {
+      console.error('❌ Type is required. Use --type rule or --type command');
+      process.exit(1);
+    }
+
+    if (!options.tag) {
+      console.error('❌ Tag is required. Use --tag <tag>');
+      process.exit(1);
+    }
+
+    // Prepare form data
+    const form = new FormData();
+    form.append('file', fs.createReadStream(filePath));
+    form.append('name', options.name || path.basename(filePath));
+    form.append('tag', options.tag);
+    form.append('type', type);
+    if (options.description) form.append('description', options.description);
+    form.append('version', options.version || '1.0.0');
+
+    console.log('Uploading...');
+
+    const response = await axios.post(`${config.server}/api/rules`, form, {
+      headers: {
+        ...form.getHeaders(),
+        Authorization: `Bearer ${config.token}`,
+      },
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity,
+    });
+
+    if (response.data && response.data.id) {
+      console.log(`✅ Uploaded successfully!`);
+      console.log(`   Name: ${response.data.name}`);
+      console.log(`   Tag: ${response.data.tag}`);
+      console.log(`   Type: ${response.data.type}`);
+      console.log(`   Version: ${response.data.version}`);
+    } else {
+      console.error('❌ Upload failed');
+      process.exit(1);
+    }
+  } catch (err: unknown) {
+    if (axios.isAxiosError(err)) {
+      const errorData = err.response?.data;
+      const errorMessage = errorData?.message || errorData?.error || err.message;
+      console.error('❌ Upload failed:', errorMessage);
+      if (errorData && typeof errorData === 'object') {
+        console.error('   Details:', JSON.stringify(errorData, null, 2));
+      }
+    } else {
+      console.error('❌ Upload failed:', err);
+    }
+    process.exit(1);
+  }
+}
+
+

package/src/config.ts

@@ -0,0 +1,66 @@
+/**
+ * @requirement TC-E2E-CLI-001
+ */
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as os from 'os';
+
+const CONFIG_DIR = process.env.KITSTORE_CONFIG_DIR || path.join(os.homedir(), '.kitstore');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+export interface Config {
+  token?: string;
+  server: string;
+  user?: {
+    id: string;
+    username: string;
+    email?: string;
+  };
+  lastLogin?: string;
+}
+
+export async function getConfig(): Promise<Config> {
+  try {
+    await fs.ensureDir(CONFIG_DIR);
+    if (await fs.pathExists(CONFIG_FILE)) {
+      const content = await fs.readJson(CONFIG_FILE);
+      // Environment variable takes precedence over config file, fallback to localhost for development
+      const server = process.env.AGENTKIT_BACKEND_URL || content.server || 'http://localhost:3000';
+      return { ...content, server };
+    }
+  } catch (err) {
+    // Ignore errors
+  }
+  // Use production backend URL if available, fallback to localhost for development
+  const server = process.env.AGENTKIT_BACKEND_URL || 'http://localhost:3000';
+  return { server };
+}
+
+export async function saveConfig(config: Config): Promise<void> {
+  await fs.ensureDir(CONFIG_DIR);
+  await fs.writeJson(CONFIG_FILE, config, { spaces: 2 });
+}
+
+export function getInstallPaths(): { rules: string; commands: string } {
+  const cwd = process.cwd();
+  const home = os.homedir();
+  
+  // Check for .cursor in current directory first
+  const cwdCursor = path.join(cwd, '.cursor');
+  if (fs.existsSync(cwdCursor)) {
+    return {
+      rules: path.join(cwdCursor, 'rules'),
+      commands: path.join(cwdCursor, 'commands'),
+    };
+  }
+  
+  // Fallback to home directory
+  return {
+    rules: path.join(home, '.cursor', 'rules'),
+    commands: path.join(home, '.cursor', 'commands'),
+  };
+}
+
+
+
+

package/src/index.ts

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { loginCommand } from './commands/login';
+import { installCommand } from './commands/install';
+import { uploadCommand } from './commands/upload';
+import { listCommand } from './commands/list';
+import { searchCommand } from './commands/search';
+import { initCommand } from './commands/init';
+import { ruleCheckCommand } from './commands/rule-check';
+import pkg from '../package.json';
+
+const program = new Command();
+
+program
+  .name('kitstore')
+  .description('CLI tool for managing Cursor rules and commands')
+  .version(pkg.version);
+
+program
+  .command('init')
+  .description('Initialize Cursor Kit in the current directory')
+  .action(initCommand);
+
+program
+  .command('rule-check')
+  .description('Check and validate a rule file')
+  .argument('<file-path>', 'Path to the rule file')
+  .action(ruleCheckCommand);
+
+program
+  .command('login')
+  .description('Login to Cursor Kit backend')
+  .option('-e, --email <email>', 'Email address')
+  .option('-p, --password <password>', 'Password')
+  .option('-s, --server <url>', 'Backend server URL', 'http://localhost:3000')
+  .action(loginCommand);
+
+program
+  .command('install')
+  .description('Install rules or commands')
+  .option('-t, --tag <tag>', 'Install by tag')
+  .option('-n, --name <name>', 'Install by name')
+  .option('--type <type>', 'Filter by type (rule|command)')
+  .option('-f, --force', 'Overwrite existing files')
+  .action(installCommand);
+
+program
+  .command('upload')
+  .description('Upload a rule or command file')
+  .argument('<file-path>', 'Path to the file to upload')
+  .option('-n, --name <name>', 'Name of the rule/command')
+  .option('-t, --tag <tag>', 'Tag (required)')
+  .option('--type <type>', 'Type: rule or command (required)')
+  .option('-d, --description <desc>', 'Description')
+  .option('--rule-version <version>', 'Version', '1.0.0')
+  .action(uploadCommand);
+
+program
+  .command('list')
+  .description('List available rules and commands')
+  .option('--type <type>', 'Filter by type (rule|command)')
+  .option('-t, --tag <tag>', 'Filter by tag')
+  .option('-n, --name <name>', 'Filter by name')
+  .option('-l, --limit <number>', 'Limit results', '20')
+  .action(listCommand);
+
+program
+  .command('search')
+  .description('Search for rules and commands')
+  .argument('<query>', 'Search query')
+  .option('--type <type>', 'Filter by type (rule|command)')
+  .option('-t, --tag <tag>', 'Filter by tag')
+  .option('-l, --limit <number>', 'Limit results', '20')
+  .action(searchCommand);
+
+program.parse();
+
+

package/test-cli-config.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+// Test script to verify CLI backend URL configuration mechanism
+
+const { execSync } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+
+console.log('🧪 Testing CLI Backend URL Configuration Mechanism...\n');
+
+// Test different configuration scenarios
+const testCases = [
+  {
+    name: 'Default configuration (no env var, no config file)',
+    env: {},
+    expectedServer: 'http://localhost:3000'
+  },
+  {
+    name: 'Environment variable override',
+    env: { AGENTKIT_BACKEND_URL: 'https://test-env.example.com' },
+    expectedServer: 'https://test-env.example.com'
+  },
+  {
+    name: 'Config file override',
+    env: {},
+    config: { server: 'https://test-config.example.com' },
+    expectedServer: 'https://test-config.example.com'
+  },
+  {
+    name: 'Environment variable takes precedence over config file',
+    env: { AGENTKIT_BACKEND_URL: 'https://test-env-precedence.example.com' },
+    config: { server: 'https://test-config-precedence.example.com' },
+    expectedServer: 'https://test-env-precedence.example.com'
+  }
+];
+
+const configDir = path.join(os.homedir(), '.agentkit');
+const configFile = path.join(configDir, 'config.json');
+
+// Helper function to run CLI config test
+async function testConfig(testCase) {
+  console.log(`📋 Testing: ${testCase.name}`);
+
+  // Set environment variables
+  const originalEnv = { ...process.env };
+  Object.assign(process.env, testCase.env);
+
+  try {
+    // Create config file if specified
+    if (testCase.config) {
+      fs.ensureDirSync(configDir);
+      fs.writeJsonSync(configFile, testCase.config);
+    } else {
+      // Remove config file
+      if (fs.existsSync(configFile)) {
+        fs.removeSync(configFile);
+      }
+    }
+
+    // Import and test the config module
+    delete require.cache[require.resolve('./dist/config.js')];
+    const config = require('./dist/config.js');
+
+    // Test getConfig function (async)
+    const result = await config.getConfig();
+    console.log(`   Expected: ${testCase.expectedServer}`);
+    console.log(`   Got: ${result.server}`);
+
+    if (result.server === testCase.expectedServer) {
+      console.log('   ✅ PASS\n');
+      return true;
+    } else {
+      console.log('   ❌ FAIL\n');
+      return false;
+    }
+
+  } catch (error) {
+    console.log(`   ❌ ERROR: ${error.message}\n`);
+    return false;
+  } finally {
+    // Restore environment
+    process.env = originalEnv;
+
+    // Clean up config file
+    if (fs.existsSync(configFile)) {
+      fs.removeSync(configFile);
+    }
+  }
+}
+
+// Run all test cases
+async function runTests() {
+  let passed = 0;
+  let total = testCases.length;
+
+  for (const testCase of testCases) {
+    if (await testConfig(testCase)) {
+      passed++;
+    }
+  }
+
+  console.log(`🎯 Test Results: ${passed}/${total} passed`);
+
+  if (passed === total) {
+    console.log('✅ All backend URL configuration tests passed!');
+    console.log('📋 Configuration precedence verified:');
+    console.log('   1. AGENTKIT_BACKEND_URL environment variable');
+    console.log('   2. Configuration file (~/.agentkit/config.json)');
+    console.log('   3. Default localhost:3000');
+  } else {
+    console.log('❌ Some configuration tests failed!');
+    process.exit(1);
+  }
+}
+
+// Run the tests
+runTests().catch(console.error);

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+
+
+
+
+
+
+