kitstore-cli 1.0.0

package/dist/commands/search.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchCommand = searchCommand;
+const config_1 = require("../config");
+const client_1 = require("../api/client");
+async function searchCommand(query, options) {
+    try {
+        const config = await (0, config_1.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 (0, client_1.createApi)({ server: config.server });
+        const queryParams = {
+            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) => {
+                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) {
+        if (err && typeof err === 'object' && 'response' in err) {
+            const axiosError = err;
+            console.error('❌ Search failed:', axiosError.response?.data?.error || axiosError.message);
+        }
+        else {
+            console.error('❌ Search failed:', err);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/upload.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadCommand = uploadCommand;
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const form_data_1 = __importDefault(require("form-data"));
+const config_1 = require("../config");
+/**
+ * @requirement TC-UNIT-CLI-004, TC-UNIT-CLI-005, TC-E2E-CLI-003
+ */
+async function uploadCommand(filePath, options) {
+    try {
+        const config = await (0, config_1.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 form_data_1.default();
+        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_1.default.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) {
+        if (axios_1.default.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/dist/config.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = getConfig;
+exports.saveConfig = saveConfig;
+exports.getInstallPaths = getInstallPaths;
+/**
+ * @requirement TC-E2E-CLI-001
+ */
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CONFIG_DIR = process.env.KITSTORE_CONFIG_DIR || path.join(os.homedir(), '.kitstore');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+async function getConfig() {
+    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 };
+}
+async function saveConfig(config) {
+    await fs.ensureDir(CONFIG_DIR);
+    await fs.writeJson(CONFIG_FILE, config, { spaces: 2 });
+}
+function getInstallPaths() {
+    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/dist/index.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const login_1 = require("./commands/login");
+const install_1 = require("./commands/install");
+const upload_1 = require("./commands/upload");
+const list_1 = require("./commands/list");
+const search_1 = require("./commands/search");
+const init_1 = require("./commands/init");
+const rule_check_1 = require("./commands/rule-check");
+const package_json_1 = __importDefault(require("../package.json"));
+const program = new commander_1.Command();
+program
+    .name('kitstore')
+    .description('CLI tool for managing Cursor rules and commands')
+    .version(package_json_1.default.version);
+program
+    .command('init')
+    .description('Initialize Cursor Kit in the current directory')
+    .action(init_1.initCommand);
+program
+    .command('rule-check')
+    .description('Check and validate a rule file')
+    .argument('<file-path>', 'Path to the rule file')
+    .action(rule_check_1.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(login_1.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(install_1.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(upload_1.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(list_1.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(search_1.searchCommand);
+program.parse();

package/e2e/install.e2e.test.ts

@@ -0,0 +1,237 @@
+import { execSync } from 'child_process';
+import { existsSync, unlinkSync, readFileSync, mkdirSync, rmSync } from 'fs';
+import * as path from 'path';
+
+// TC-E2E-CLI-002: Install rule flow
+// TC-E2E-CLI-005: List rules
+// TC-E2E-CLI-011: Search rules
+describe('CLI Install E2E Tests', () => {
+  const tempHome = path.join(process.cwd(), 'temp-home-install');
+  const configDir = path.join(tempHome, '.kitstore');
+  const configPath = path.join(configDir, 'config.json');
+  const installDir = path.join(tempHome, '.cursor');
+  const rulesDir = path.join(installDir, 'rules');
+  const cliPath = path.join(process.cwd(), 'dist', 'index.js');
+
+  beforeAll(() => {
+    if (!existsSync(tempHome)) {
+      mkdirSync(tempHome, { recursive: true });
+    }
+  });
+
+  beforeEach(() => {
+    // Setup mock config for authenticated user
+    const config = {
+      server: 'http://localhost:3000',
+      token: 'test-token',
+      user: { id: 'test-user-id', username: 'testuser' },
+      lastLogin: new Date().toISOString(),
+    };
+
+    // Ensure config directory exists
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+    require('fs').writeFileSync(configPath, JSON.stringify(config, null, 2));
+  });
+
+  afterAll(() => {
+    // Clean up temp home
+    if (existsSync(tempHome)) {
+      rmSync(tempHome, { recursive: true, force: true });
+    }
+  });
+
+  afterEach(() => {
+    // Clean up config and installed rules
+    if (existsSync(configPath)) {
+      unlinkSync(configPath);
+    }
+    if (existsSync(rulesDir)) {
+      rmSync(rulesDir, { recursive: true, force: true });
+    }
+  });
+
+  // TC-E2E-CLI-005: List rules
+  test('should list rules successfully', () => {
+    // Skip if CLI is not built
+    if (!existsSync(cliPath)) {
+      console.warn('Skipping test: CLI not built');
+      return;
+    }
+
+    try {
+      // Run list command
+      const result = execSync(`node ${cliPath} list`, {
+        encoding: 'utf8',
+        timeout: 10000,
+        env: { 
+          ...process.env, 
+          NODE_ENV: 'test',
+          AGENTKIT_CONFIG_DIR: configDir,
+          HOME: tempHome,
+          USERPROFILE: tempHome,
+          HOMEDRIVE: tempHome.substring(0, 2),
+          HOMEPATH: tempHome.substring(2)
+        }
+      });
+
+      // Should show found rules or empty message
+      expect(result).toMatch(/📋 Found \d+ rules\/commands|📭 No rules or commands found/);
+
+    } catch (error: any) {
+      // If backend not running, skip test
+      const output = (error.stdout || '') + (error.stderr || '');
+      if (
+        output.includes('ECONNREFUSED') || 
+        output.includes('ENOTFOUND') ||
+        output.includes('Not logged in') ||
+        output.includes('Failed to list rules') ||
+        output.includes('failed: Error')
+      ) {
+        console.warn('Skipping test: Backend server not running or unauthorized');
+        return;
+      } else {
+        throw error;
+      }
+    }
+  });
+
+  // TC-E2E-CLI-011: Search rules
+  test('should search rules successfully', () => {
+    // Skip if CLI is not built
+    if (!existsSync(cliPath)) {
+      console.warn('Skipping test: CLI not built');
+      return;
+    }
+
+    try {
+      // Run search command
+      const result = execSync(`node ${cliPath} search "test"`, {
+        encoding: 'utf8',
+        timeout: 10000,
+        env: { 
+          ...process.env, 
+          NODE_ENV: 'test',
+          AGENTKIT_CONFIG_DIR: configDir,
+          HOME: tempHome,
+          USERPROFILE: tempHome,
+          HOMEDRIVE: tempHome.substring(0, 2),
+          HOMEPATH: tempHome.substring(2)
+        }
+      });
+
+      // Should show search results
+      expect(result).toMatch(/🔍 Search results for "test"|🔍 No rules or commands found matching "test"/);
+
+    } catch (error: any) {
+      // If backend not running, skip test
+      const output = (error.stdout || '') + (error.stderr || '');
+      if (
+        output.includes('ECONNREFUSED') || 
+        output.includes('ENOTFOUND') ||
+        output.includes('Not logged in') ||
+        output.includes('Failed to list rules') ||
+        output.includes('failed: Error')
+      ) {
+        console.warn('Skipping test: Backend server not running or unauthorized');
+        return;
+      } else {
+        throw error;
+      }
+    }
+  });
+
+  // TC-E2E-CLI-012: List with filters
+  test('should list rules with tag filter', () => {
+    // Skip if CLI is not built
+    if (!existsSync(cliPath)) {
+      console.warn('Skipping test: CLI not built');
+      return;
+    }
+
+    try {
+      // Run list command with tag filter
+      const result = execSync(`node ${cliPath} list --tag test`, {
+        encoding: 'utf8',
+        timeout: 10000,
+        env: { 
+          ...process.env, 
+          NODE_ENV: 'test',
+          AGENTKIT_CONFIG_DIR: configDir,
+          HOME: tempHome,
+          USERPROFILE: tempHome,
+          HOMEDRIVE: tempHome.substring(0, 2),
+          HOMEPATH: tempHome.substring(2)
+        }
+      });
+
+      // Should show filtered results
+      expect(result).toMatch(/📋 Found \d+ rules\/commands|📭 No rules or commands found/);
+
+    } catch (error: any) {
+      // If backend not running, skip test
+      const output = (error.stdout || '') + (error.stderr || '');
+      if (
+        output.includes('ECONNREFUSED') || 
+        output.includes('ENOTFOUND') ||
+        output.includes('Not logged in') ||
+        output.includes('Failed to list rules') ||
+        output.includes('failed: Error')
+      ) {
+        console.warn('Skipping test: Backend server not running or unauthorized');
+        return;
+      } else {
+        throw error;
+      }
+    }
+  });
+
+  // TC-E2E-CLI-013: List with type filter
+  test('should list rules with type filter', () => {
+    // Skip if CLI is not built
+    if (!existsSync(cliPath)) {
+      console.warn('Skipping test: CLI not built');
+      return;
+    }
+
+    try {
+      // Run list command with type filter
+      const result = execSync(`node ${cliPath} list --type rule`, {
+        encoding: 'utf8',
+        timeout: 10000,
+        env: { 
+          ...process.env, 
+          NODE_ENV: 'test',
+          AGENTKIT_CONFIG_DIR: configDir,
+          HOME: tempHome,
+          USERPROFILE: tempHome,
+          HOMEDRIVE: tempHome.substring(0, 2),
+          HOMEPATH: tempHome.substring(2)
+        }
+      });
+
+      // Should show filtered results
+      expect(result).toMatch(/📋 Found \d+ rules\/commands|📭 No rules or commands found/);
+
+    } catch (error: any) {
+      // If backend not running, skip test
+      const output = (error.stdout || '') + (error.stderr || '');
+      if (
+        output.includes('ECONNREFUSED') || 
+        output.includes('ENOTFOUND') ||
+        output.includes('Not logged in') ||
+        output.includes('Failed to list rules') ||
+        output.includes('failed: Error')
+      ) {
+        console.warn('Skipping test: Backend server not running or unauthorized');
+        return;
+      } else {
+        throw error;
+      }
+    }
+  });
+});
+
+
+