tokrepo 1.1.0

package/bin/tokrepo.js

@@ -0,0 +1,708 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const readline = require('readline');
+
+// ANSI colors
+const C = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+};
+
+const CONFIG_DIR = path.join(require('os').homedir(), '.tokrepo');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const PROJECT_CONFIG = '.tokrepo.json';
+const DEFAULT_API = 'https://api.tokrepo.com';
+
+// ─── Helpers ───
+
+function log(msg) { console.log(msg); }
+function success(msg) { log(`${C.green}✓${C.reset} ${msg}`); }
+function error(msg) { log(`${C.red}✗${C.reset} ${msg}`); process.exit(1); }
+function warn(msg) { log(`${C.yellow}!${C.reset} ${msg}`); }
+function info(msg) { log(`${C.cyan}→${C.reset} ${msg}`); }
+
+function readConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+function readProjectConfig(baseDir = process.cwd()) {
+  const configPath = path.join(baseDir, PROJECT_CONFIG);
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function ask(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`${C.cyan}?${C.reset} ${question} `, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function fetchCurrentUser(config) {
+  return apiRequest('GET', '/api/v1/tokenboard/auth/me', null, config.token, config.api);
+}
+
+function apiRequest(method, urlPath, body, token, apiBase) {
+  return new Promise((resolve, reject) => {
+    const base = apiBase || DEFAULT_API;
+    const url = new URL(urlPath, base);
+    const isHttps = url.protocol === 'https:';
+    const mod = isHttps ? https : http;
+
+    const headers = {
+      'Content-Type': 'application/json',
+      'User-Agent': 'tokrepo-cli/1.1.0',
+    };
+    if (token) {
+      headers['Authorization'] = `Bearer ${token}`;
+    }
+
+    const bodyStr = body ? JSON.stringify(body) : null;
+    if (bodyStr) {
+      headers['Content-Length'] = Buffer.byteLength(bodyStr);
+    }
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method,
+      headers,
+    };
+
+    const req = mod.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          if (json.code === 200) {
+            resolve(json.data);
+          } else {
+            reject(new Error(json.message || `API error: ${json.code}`));
+          }
+        } catch {
+          reject(new Error(`Invalid response: ${data.substring(0, 200)}`));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    if (bodyStr) req.write(bodyStr);
+    req.end();
+  });
+}
+
+// ─── File type detection (auto from extension) ───
+
+function detectFileType(filename) {
+  const lower = filename.toLowerCase();
+  // Skills
+  if (lower.endsWith('.skill.md') || lower === 'skill.md') return 'skill';
+  // Prompts
+  if (lower.endsWith('.prompt') || lower.endsWith('.prompt.md')) return 'prompt';
+  // Configs
+  if (lower === 'claude.md' || lower === '.claude.md' || lower === 'agents.md' || lower === '.agents.md') return 'config';
+  if (lower === 'gemini.md' || lower === '.gemini.md') return 'config';
+  if (lower === '.cursorrules' || lower === '.windsurfrules') return 'config';
+  if (lower.endsWith('.mcp.json') || lower.endsWith('.yaml') || lower.endsWith('.yml') || lower.endsWith('.toml')) return 'config';
+  if (lower.endsWith('.json') && !lower.endsWith('package.json') && !lower.endsWith('package-lock.json')) return 'config';
+  // Scripts
+  if (/\.(sh|py|js|mjs|ts|rb|go|rs|lua)$/.test(lower)) return 'script';
+  // Markdown defaults to other (content)
+  if (lower.endsWith('.md')) return 'other';
+  return 'other';
+}
+
+// Guess tag from file type
+function guessTag(fileType) {
+  const map = { skill: 'Skills', prompt: 'Prompts', script: 'Scripts', config: 'Configs' };
+  return map[fileType] || null;
+}
+
+// ─── Glob matching ───
+
+function matchGlob(pattern, filename) {
+  const regex = pattern
+    .replace(/\./g, '\\.')
+    .replace(/\*\*/g, '{{GLOBSTAR}}')
+    .replace(/\*/g, '[^/]*')
+    .replace(/\{\{GLOBSTAR\}\}/g, '.*')
+    .replace(/\?/g, '.');
+  return new RegExp(`^${regex}$`).test(filename);
+}
+
+function findFiles(patterns, baseDir) {
+  const results = new Set();
+  const seen = new Set();
+
+  function walk(dir, relBase) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      const fullPath = path.join(dir, entry.name);
+      const relPath = relBase ? `${relBase}/${entry.name}` : entry.name;
+
+      if (entry.isDirectory()) {
+        walk(fullPath, relPath);
+      } else if (entry.isFile()) {
+        for (const pattern of patterns) {
+          if (matchGlob(pattern, relPath) || matchGlob(pattern, entry.name)) {
+            if (!seen.has(relPath)) {
+              seen.add(relPath);
+              results.add({ path: fullPath, relPath });
+            }
+          }
+        }
+      }
+    }
+  }
+
+  walk(baseDir, '');
+  return Array.from(results);
+}
+
+// ─── Parse CLI args ───
+
+function parseArgs(argv) {
+  const args = { flags: {}, positional: [] };
+  let i = 2; // skip node and script
+  // skip command name
+  if (argv[i] && !argv[i].startsWith('-')) {
+    args.command = argv[i];
+    i++;
+  }
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === '--public') {
+      args.flags.public = true;
+    } else if (arg === '--private') {
+      args.flags.private = true;
+    } else if (arg === '--title' && i + 1 < argv.length) {
+      args.flags.title = argv[++i];
+    } else if (arg.startsWith('--title=')) {
+      args.flags.title = arg.split('=').slice(1).join('=');
+    } else if (arg === '--desc' && i + 1 < argv.length) {
+      args.flags.desc = argv[++i];
+    } else if (arg.startsWith('--desc=')) {
+      args.flags.desc = arg.split('=').slice(1).join('=');
+    } else if (arg === '--tag' && i + 1 < argv.length) {
+      if (!args.flags.tags) args.flags.tags = [];
+      args.flags.tags.push(argv[++i]);
+    } else if (arg.startsWith('--tag=')) {
+      if (!args.flags.tags) args.flags.tags = [];
+      args.flags.tags.push(arg.split('=').slice(1).join('='));
+    } else if (arg === '-y' || arg === '--yes') {
+      args.flags.yes = true;
+    } else if (!arg.startsWith('-')) {
+      args.positional.push(arg);
+    }
+    i++;
+  }
+  return args;
+}
+
+// ─── Collect files from paths ───
+
+function collectFiles(paths, baseDir) {
+  const files = [];
+  const DEFAULT_PATTERNS = [
+    '*.md', '*.skill.md', '*.prompt', '*.prompt.md',
+    '*.sh', '*.py', '*.js', '*.mjs', '*.ts',
+    '*.json', '*.yaml', '*.yml', '*.toml',
+  ];
+  // Skip binary/irrelevant files
+  const SKIP = new Set([
+    'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
+    '.DS_Store', 'Thumbs.db', '.gitignore', '.npmignore',
+  ]);
+  const SKIP_DIRS = new Set(['node_modules', '.git', '.next', '.nuxt', 'dist', 'build', '__pycache__', '.venv', 'venv']);
+
+  for (const p of paths) {
+    const resolved = path.resolve(baseDir, p);
+    if (!fs.existsSync(resolved)) {
+      warn(`Not found: ${p}`);
+      continue;
+    }
+
+    const stat = fs.statSync(resolved);
+    if (stat.isFile()) {
+      // Direct file
+      if (SKIP.has(path.basename(resolved))) continue;
+      files.push({ path: resolved, relPath: path.basename(resolved) });
+    } else if (stat.isDirectory()) {
+      // Scan directory
+      function walk(dir, relBase) {
+        let entries;
+        try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+        for (const entry of entries) {
+          if (entry.name.startsWith('.') || SKIP_DIRS.has(entry.name) || SKIP.has(entry.name)) continue;
+          const fullPath = path.join(dir, entry.name);
+          const relPath = relBase ? `${relBase}/${entry.name}` : entry.name;
+          if (entry.isDirectory()) {
+            walk(fullPath, relPath);
+          } else if (entry.isFile()) {
+            // Check extension matches
+            const ext = path.extname(entry.name).toLowerCase();
+            const validExts = ['.md', '.sh', '.py', '.js', '.mjs', '.ts', '.json', '.yaml', '.yml', '.toml', '.prompt', '.rb', '.go', '.rs'];
+            if (validExts.includes(ext) || entry.name === '.cursorrules' || entry.name === '.windsurfrules') {
+              if (!SKIP.has(entry.name)) {
+                files.push({ path: fullPath, relPath });
+              }
+            }
+          }
+        }
+      }
+      walk(resolved, '');
+    }
+  }
+  return files;
+}
+
+// ─── Guess title from directory or README ───
+
+function guessTitle(files, baseDir) {
+  // Try README first line
+  const readme = files.find(f => /^readme\.md$/i.test(path.basename(f.relPath)));
+  if (readme) {
+    const content = fs.readFileSync(readme.path, 'utf8');
+    const firstHeading = content.match(/^#\s+(.+)$/m);
+    if (firstHeading) return firstHeading[1].trim();
+  }
+  // Fall back to directory name
+  return path.basename(baseDir);
+}
+
+// ─── Commands ───
+
+async function cmdLogin() {
+  log(`\n${C.bold}tokrepo login${C.reset}\n`);
+  info('Get your API token from https://tokrepo.com/en/workflows/submit');
+  log('');
+
+  const token = await ask('API Token:');
+  if (!token) error('Token is required');
+
+  writeConfig({ token, api: DEFAULT_API });
+  success(`Config saved to ${CONFIG_FILE}`);
+
+  try {
+    const config = readConfig();
+    const data = await fetchCurrentUser(config);
+    success(`Logged in as ${C.bold}${data.nickname}${C.reset} (${data.email})`);
+  } catch (e) {
+    warn(`Token saved but verification failed: ${e.message}`);
+  }
+}
+
+async function cmdPush() {
+  const args = parseArgs(process.argv);
+
+  const config = readConfig();
+  if (!config || !config.token) {
+    error(`Not logged in. Run: ${C.cyan}tokrepo login${C.reset}`);
+  }
+
+  const projectConfig = readProjectConfig();
+  const baseDir = process.cwd();
+
+  // Determine what to push
+  let filesToPush;
+  let title;
+  let description;
+  let visibility;
+  let tags;
+
+  if (args.positional.length > 0) {
+    // Direct mode: tokrepo push [files/dirs...] --public --title "..."
+    filesToPush = collectFiles(args.positional, baseDir);
+  } else if (projectConfig) {
+    // Config mode: use .tokrepo.json
+    const patterns = projectConfig.files || ['*.md'];
+    filesToPush = findFiles(patterns, baseDir);
+    title = projectConfig.title;
+    description = projectConfig.description;
+    tags = projectConfig.tags;
+  } else {
+    // No config, no files specified: push current directory
+    filesToPush = collectFiles(['.'], baseDir);
+  }
+
+  if (filesToPush.length === 0) {
+    error('No pushable files found. Specify files or run in a directory with .md/.py/.js/.sh files.');
+  }
+
+  // Flags override config
+  title = args.flags.title || title || guessTitle(filesToPush, baseDir);
+  description = args.flags.desc || description || '';
+  visibility = args.flags.public ? 1 : (args.flags.private ? 0 : (projectConfig?.visibility ?? 1));
+  tags = args.flags.tags || tags || [];
+
+  // Read files and detect types
+  const pushFiles = [];
+  const detectedTags = new Set(tags);
+
+  for (const f of filesToPush) {
+    let content;
+    try {
+      content = fs.readFileSync(f.path, 'utf8');
+    } catch {
+      warn(`Cannot read: ${f.relPath} (binary or unreadable, skipping)`);
+      continue;
+    }
+    // Skip empty files
+    if (!content.trim()) continue;
+
+    const fileType = detectFileType(f.relPath);
+    const tag = guessTag(fileType);
+    if (tag) detectedTags.add(tag);
+
+    pushFiles.push({
+      name: f.relPath,
+      content,
+      type: fileType,
+    });
+  }
+
+  if (pushFiles.length === 0) {
+    error('No readable text files found to push.');
+  }
+
+  // Show summary
+  log(`\n${C.bold}tokrepo push${C.reset}\n`);
+  log(`  ${C.bold}Title:${C.reset}      ${title}`);
+  log(`  ${C.bold}Visibility:${C.reset} ${visibility === 1 ? `${C.green}public${C.reset}` : `${C.yellow}private${C.reset}`}`);
+  log(`  ${C.bold}Files:${C.reset}      ${pushFiles.length}`);
+  if (detectedTags.size > 0) {
+    log(`  ${C.bold}Tags:${C.reset}       ${Array.from(detectedTags).join(', ')}`);
+  }
+  log('');
+
+  for (const f of pushFiles) {
+    const sizeKb = (Buffer.byteLength(f.content) / 1024).toFixed(1);
+    log(`  ${C.dim}•${C.reset} ${f.name} ${C.dim}(${f.type}, ${sizeKb}KB)${C.reset}`);
+  }
+  log('');
+
+  const totalChars = pushFiles.reduce((sum, f) => sum + f.content.length, 0);
+
+  // Push
+  info('Pushing...');
+
+  try {
+    const data = await apiRequest('POST', '/api/v1/tokenboard/push/create', {
+      title,
+      description,
+      files: pushFiles,
+      tags: Array.from(detectedTags),
+      token_cost: String(Math.round(totalChars / 4)),
+      visibility: visibility,
+    }, config.token, config.api);
+
+    log('');
+    success(`Pushed!`);
+    log(`\n  ${C.bold}URL:${C.reset}  ${C.cyan}${data.url}${C.reset}`);
+    log(`  ${C.bold}UUID:${C.reset} ${data.uuid}\n`);
+  } catch (e) {
+    error(`Push failed: ${e.message}`);
+  }
+}
+
+async function cmdInit() {
+  log(`\n${C.bold}tokrepo init${C.reset}\n`);
+
+  const existing = readProjectConfig();
+  if (existing) {
+    warn(`${PROJECT_CONFIG} already exists.`);
+    const overwrite = await ask('Overwrite? (y/N):');
+    if (overwrite.toLowerCase() !== 'y') {
+      log('Aborted.');
+      return;
+    }
+  }
+
+  const dirName = path.basename(process.cwd());
+  const title = await ask(`Title (${dirName}):`);
+  const description = await ask('Description:');
+
+  const config = {
+    title: title || dirName,
+    description: description || '',
+    files: ['*.md', '*.sh', '*.py', '*.js', '*.mjs', '*.ts', '*.json', '*.yaml'],
+    visibility: 1,
+    tags: [],
+  };
+
+  fs.writeFileSync(
+    path.join(process.cwd(), PROJECT_CONFIG),
+    JSON.stringify(config, null, 2) + '\n'
+  );
+
+  success(`Created ${PROJECT_CONFIG}`);
+  log(`\n${C.dim}Then run: tokrepo push${C.reset}\n`);
+}
+
+async function cmdPull() {
+  const urlOrUuid = process.argv[3];
+  if (!urlOrUuid) error('Usage: tokrepo pull <url-or-uuid>');
+
+  log(`\n${C.bold}tokrepo pull${C.reset}\n`);
+
+  let uuid = urlOrUuid;
+  const urlMatch = urlOrUuid.match(/workflows\/([a-f0-9-]+)/);
+  if (urlMatch) uuid = urlMatch[1];
+
+  const config = readConfig();
+  const apiBase = config?.api || DEFAULT_API;
+
+  info(`Fetching ${uuid}...`);
+
+  try {
+    const data = await apiRequest('GET', `/api/v1/tokenboard/workflows/detail?uuid=${uuid}`, null, config?.token, apiBase);
+    const workflow = data.workflow;
+    log(`\n  ${C.bold}${workflow.title}${C.reset}`);
+
+    if (workflow.steps && workflow.steps.length > 0) {
+      for (const step of workflow.steps) {
+        const content = step.prompt_template || step.promptTemplate;
+        if (content) {
+          const fileName = `${step.title || 'step-' + step.step_order}.md`;
+          const safeName = fileName.replace(/[/\\?%*:|"<>]/g, '-');
+          fs.writeFileSync(path.join(process.cwd(), safeName), content);
+          success(`Downloaded: ${safeName}`);
+        }
+      }
+    }
+    log('');
+    success('Pull complete!');
+  } catch (e) {
+    error(`Pull failed: ${e.message}`);
+  }
+}
+
+async function cmdWhoami() {
+  const config = readConfig();
+  if (!config || !config.token) error('Not logged in. Run: tokrepo login');
+
+  try {
+    const data = await fetchCurrentUser(config);
+    log(`\n${C.bold}Logged in as:${C.reset}`);
+    log(`  ${C.bold}Name:${C.reset}  ${data.nickname}`);
+    log(`  ${C.bold}Email:${C.reset} ${data.email}`);
+    log(`  ${C.bold}UUID:${C.reset}  ${data.uuid}`);
+    log(`  ${C.bold}API:${C.reset}   ${config.api}\n`);
+  } catch (e) {
+    error(`Auth failed: ${e.message}`);
+  }
+}
+
+async function cmdList() {
+  log(`\n${C.bold}tokrepo list${C.reset}\n`);
+
+  const config = readConfig();
+  if (!config || !config.token) error('Not logged in. Run: tokrepo login');
+
+  try {
+    const data = await apiRequest('GET', '/api/v1/tokenboard/workflows/my?page=1&page_size=50', null, config.token, config.api);
+
+    if (!data.list || data.list.length === 0) {
+      info('No assets found. Run: tokrepo push');
+      return;
+    }
+
+    log(`  ${C.bold}${data.total}${C.reset} assets:\n`);
+
+    for (const wf of data.list) {
+      const views = wf.view_count || 0;
+      log(`  ${C.cyan}${wf.uuid.substring(0,8)}${C.reset}  ${C.bold}${wf.title}${C.reset}`);
+      log(`  ${C.dim}         ${views} views · https://tokrepo.com/en/workflows/${wf.uuid}${C.reset}\n`);
+    }
+  } catch (e) {
+    error(`Failed: ${e.message}`);
+  }
+}
+
+async function cmdUpdate() {
+  const uuid = process.argv[3];
+  if (!uuid) error('Usage: tokrepo update <uuid> [file]');
+
+  log(`\n${C.bold}tokrepo update${C.reset}\n`);
+
+  const config = readConfig();
+  if (!config || !config.token) error('Not logged in. Run: tokrepo login');
+
+  const filePath = process.argv[4];
+  let body = { uuid };
+
+  if (filePath) {
+    const fullPath = path.resolve(filePath);
+    if (!fs.existsSync(fullPath)) error(`File not found: ${filePath}`);
+
+    const content = fs.readFileSync(fullPath, 'utf8');
+    body.steps = [{
+      id: 0,
+      step_order: 1,
+      title: body.title || path.basename(filePath),
+      description: '',
+      prompt_template: content,
+      variables: '{}',
+      depends_on: '',
+      expected_output: '',
+    }];
+  }
+
+  info(`Updating ${uuid.substring(0,8)}...`);
+
+  try {
+    await apiRequest('PUT', '/api/v1/tokenboard/workflows/update', body, config.token, config.api);
+    success('Updated!');
+    log(`  ${C.dim}https://tokrepo.com/en/workflows/${uuid}${C.reset}\n`);
+  } catch (e) {
+    error(`Update failed: ${e.message}`);
+  }
+}
+
+async function cmdDelete() {
+  const uuid = process.argv[3];
+  if (!uuid) error('Usage: tokrepo delete <uuid>');
+
+  log(`\n${C.bold}tokrepo delete${C.reset}\n`);
+
+  const config = readConfig();
+  if (!config || !config.token) error('Not logged in. Run: tokrepo login');
+
+  const confirm = await ask(`Delete ${uuid.substring(0,8)}...? (y/N):`);
+  if (confirm.toLowerCase() !== 'y') { log('Aborted.'); return; }
+
+  try {
+    await apiRequest('DELETE', '/api/v1/tokenboard/workflows/delete', { uuid }, config.token, config.api);
+    success('Deleted!');
+  } catch (e) {
+    error(`Delete failed: ${e.message}`);
+  }
+}
+
+async function cmdTags() {
+  log(`\n${C.bold}tokrepo tags${C.reset}\n`);
+
+  const config = readConfig();
+  const apiBase = config?.api || DEFAULT_API;
+
+  try {
+    const data = await apiRequest('GET', '/api/v1/tokenboard/tags/list', null, null, apiBase);
+    log(`  Available tags:\n`);
+    for (const tag of data.tags) {
+      log(`  ${C.cyan}${tag.name}${C.reset}${tag.count ? ` ${C.dim}(${tag.count} assets)${C.reset}` : ''}`);
+    }
+    log('');
+  } catch (e) {
+    error(`Failed: ${e.message}`);
+  }
+}
+
+function showHelp() {
+  log(`
+${C.bold}tokrepo${C.reset} — Push AI assets to tokrepo.com
+
+${C.bold}QUICK START${C.reset}
+  ${C.cyan}tokrepo login${C.reset}                          # one-time: paste your token
+  ${C.cyan}tokrepo push --public .${C.reset}                # push current directory
+  ${C.cyan}tokrepo push --public README.md script.py${C.reset}  # push specific files
+
+${C.bold}USAGE${C.reset}
+  tokrepo push [files/dirs...] [options]
+
+${C.bold}OPTIONS${C.reset}
+  ${C.cyan}--public${C.reset}            Make asset publicly visible (default)
+  ${C.cyan}--private${C.reset}           Make asset private
+  ${C.cyan}--title${C.reset} "..."       Set title (auto-detected from README or dir name)
+  ${C.cyan}--desc${C.reset} "..."        Set description
+  ${C.cyan}--tag${C.reset} Skills        Add tag (repeatable: --tag Skills --tag MCP)
+  ${C.cyan}-y, --yes${C.reset}           Skip confirmation prompts
+
+${C.bold}COMMANDS${C.reset}
+  ${C.cyan}login${C.reset}              Save API token
+  ${C.cyan}push${C.reset} [files...]    Push files/directory (default: current dir)
+  ${C.cyan}init${C.reset}               Create .tokrepo.json project config
+  ${C.cyan}pull${C.reset} <url>         Download asset to local files
+  ${C.cyan}list${C.reset}               List your assets
+  ${C.cyan}update${C.reset} <uuid> [f]  Update existing asset
+  ${C.cyan}delete${C.reset} <uuid>      Delete an asset
+  ${C.cyan}tags${C.reset}               List available tags
+  ${C.cyan}whoami${C.reset}             Show current user
+  ${C.cyan}help${C.reset}               Show this help
+
+${C.bold}EXAMPLES${C.reset}
+  tokrepo push --public .                     # Push all files in current dir
+  tokrepo push --public --title "My MCP" .    # Push with custom title
+  tokrepo push --public src/ README.md        # Push specific paths
+  tokrepo push                                # Uses .tokrepo.json if exists
+
+${C.bold}FILE TYPE AUTO-DETECTION${C.reset}
+  .sh .py .js .ts .mjs .go .rs  →  script
+  .json .yaml .yml .toml        →  config
+  .skill.md                     →  skill
+  .prompt .prompt.md            →  prompt
+  .md (other)                   →  other
+
+${C.bold}GET YOUR TOKEN${C.reset}
+  https://tokrepo.com/en/workflows/submit
+`);
+}
+
+// ─── Main ───
+
+async function main() {
+  const command = process.argv[2];
+
+  switch (command) {
+    case 'login': await cmdLogin(); break;
+    case 'init': await cmdInit(); break;
+    case 'push': await cmdPush(); break;
+    case 'pull': await cmdPull(); break;
+    case 'list': await cmdList(); break;
+    case 'update': await cmdUpdate(); break;
+    case 'delete': await cmdDelete(); break;
+    case 'tags': await cmdTags(); break;
+    case 'whoami': await cmdWhoami(); break;
+    case 'help': case '--help': case '-h': case undefined:
+      showHelp(); break;
+    default:
+      error(`Unknown command: ${command}. Run: tokrepo help`);
+  }
+}
+
+main().catch((e) => { error(e.message); });

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "tokrepo",
+  "version": "1.1.0",
+  "description": "Push AI assets to tokrepo.com — Skills, Prompts, MCP Configs, Scripts",
+  "bin": {
+    "tokrepo": "bin/tokrepo.js"
+  },
+  "files": [
+    "bin/"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tokrepo/cli.git"
+  },
+  "homepage": "https://tokrepo.com",
+  "keywords": [
+    "ai",
+    "prompt",
+    "skill",
+    "workflow",
+    "mcp",
+    "tokrepo",
+    "claude",
+    "codex",
+    "cursor",
+    "gemini",
+    "agent"
+  ],
+  "engines": {
+    "node": ">=16"
+  }
+}