trackly-cli 0.1.0

package/README.md

@@ -0,0 +1,71 @@
+# @trackly/cli
+
+Trackly job tracker CLI + MCP server for AI agents.
+
+## Install
+
+```bash
+npm install -g @trackly/cli
+```
+
+## Login
+
+```bash
+trackly login
+```
+
+Opens Google OAuth in your browser. Credentials are stored in `~/.trackly/config.json`.
+
+## CLI Usage
+
+```bash
+trackly jobs                          # List jobs
+trackly jobs --modality remote        # Filter remote jobs
+trackly jobs --function engineering   # Filter by function
+trackly job 1234                      # Get job details
+trackly companies                     # List companies
+trackly search "fintech"              # Semantic company search
+trackly stats                         # Show metrics
+trackly apply 1234                    # Mark as applied
+trackly save 1234                     # Save a job
+trackly dismiss 1234                  # Dismiss a job
+trackly ask "PM jobs in SF"           # Natural language search (20/day)
+trackly api-key create                # Generate API key
+trackly api-key list                  # List API keys
+trackly whoami                        # Show current user
+trackly logout                        # Clear credentials
+```
+
+Add `--json` to any command for JSON output.
+
+## MCP Server (Claude Code)
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "trackly": {
+      "command": "trackly",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+Then use natural language in Claude Code:
+- "Find me PM jobs at fintech companies"
+- "What remote engineering roles are available?"
+- "Mark job 1234 as applied"
+
+## API Key
+
+For programmatic access without OAuth:
+
+```bash
+trackly api-key create --name "my-script"
+```
+
+## License
+
+MIT

package/bin/trackly

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+'use strict';
+
+const { loadConfig, saveConfig, clearConfig, apiRequest, getToken, CONFIG_DIR } = require('../lib/client');
+const { color, isJSON, outputJobs, outputCompanies, outputStats, outputError } = require('../lib/formatters');
+const http = require('http');
+const crypto = require('crypto');
+const { execSync } = require('child_process');
+const path = require('path');
+
+function parseArgs(args) {
+  const result = { _: [], command: null };
+  let i = 0;
+  while (i < args.length && !args[i].startsWith('-')) {
+    if (!result.command) result.command = args[i];
+    else result._.push(args[i]);
+    i++;
+  }
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+        result[key] = args[i + 1]; i += 2;
+      } else { result[key] = true; i++; }
+    } else { result._.push(arg); i++; }
+  }
+  return result;
+}
+
+// -- Commands --
+
+async function cmdLogin() {
+  const port = 19847 + Math.floor(Math.random() * 1000);
+  const baseUrl = loadConfig().baseUrl || 'https://closeai.mba';
+  const state = crypto.randomBytes(16).toString('hex');
+
+  console.log(color('cyan', 'Opening browser for Google login...'));
+  console.log(color('dim', `Callback server on port ${port}`));
+
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      if (url.pathname === '/callback') {
+        const returnedState = url.searchParams.get('state');
+        if (returnedState !== state) {
+          res.writeHead(403, { 'Content-Type': 'text/html' });
+          res.end('<html><body><h2>Login failed. Invalid state parameter (possible CSRF).</h2></body></html>');
+          server.close();
+          reject(new Error('CSRF state mismatch'));
+          return;
+        }
+        const token = url.searchParams.get('token');
+        const refreshToken = url.searchParams.get('refreshToken');
+        if (token) {
+          saveConfig({ ...loadConfig(), token, refreshToken, baseUrl });
+          res.writeHead(200, { 'Content-Type': 'text/html' });
+          res.end('<html><body><h2>Logged in! You can close this tab.</h2><script>window.close()</script></body></html>');
+          console.log(color('green', 'Login successful!'));
+          server.close();
+          resolve();
+        } else {
+          res.writeHead(400, { 'Content-Type': 'text/html' });
+          res.end('<html><body><h2>Login failed. No token received.</h2></body></html>');
+          server.close();
+          reject(new Error('No token received'));
+        }
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+
+    server.listen(port, '127.0.0.1', () => {
+      const loginUrl = `${baseUrl}/auth/google/cli?port=${port}&state=${state}`;
+      try {
+        if (process.platform === 'darwin') execSync(`open "${loginUrl}"`);
+        else if (process.platform === 'linux') execSync(`xdg-open "${loginUrl}"`);
+        else console.log(`Open this URL in your browser:\n${loginUrl}`);
+      } catch {
+        console.log(`Open this URL in your browser:\n${loginUrl}`);
+      }
+    });
+
+    // Timeout after 2 minutes
+    setTimeout(() => { server.close(); reject(new Error('Login timed out')); }, 120000);
+  });
+}
+
+async function cmdLogout() {
+  clearConfig();
+  console.log(color('green', 'Logged out. Credentials cleared.'));
+}
+
+async function cmdWhoami() {
+  if (!getToken()) { outputError('Not logged in. Run: trackly login'); process.exit(1); }
+  try {
+    const result = await apiRequest('GET', '/api/auth/user');
+    if (result.success && result.user) {
+      if (isJSON()) return console.log(JSON.stringify(result.user, null, 2));
+      console.log(`${color('bold', result.user.name || 'Unknown')}`);
+      console.log(`  Email: ${color('cyan', result.user.email)}`);
+      console.log(`  ID: ${color('dim', result.user.id)}`);
+    } else {
+      outputError('Not authenticated. Run: trackly login');
+    }
+  } catch (e) {
+    outputError(e.error || e.message || 'Failed to get user info');
+  }
+}
+
+async function cmdJobs(args) {
+  if (!getToken()) { outputError('Not logged in. Run: trackly login'); process.exit(1); }
+  const params = new URLSearchParams();
+  if (args.function) params.set('function', args.function);
+  if (args.location) params.set('location', args.location);
+  if (args.modality) params.set('modality', args.modality);
+  if (args.status) params.set('status', args.status);
+  if (args.sort) params.set('sort', args.sort);
+  if (args.limit) params.set('limit', args.limit);
+  if (args.offset) params.set('offset', args.offset);
+  if (args.keywords) params.set('keywords', args.keywords);
+
+  const qs = params.toString();
+  try {
+    const result = await apiRequest('GET', `/api/jobscout/jobs${qs ? '?' + qs : ''}`);
+    outputJobs(result.jobs || result.data || []);
+    if (!isJSON() && result.total) console.log(color('dim', `Showing ${(result.jobs || result.data || []).length} of ${result.total} jobs`));
+  } catch (e) {
+    outputError(e.error || e.message || 'Failed to fetch jobs');
+  }
+}
+
+async function cmdJob(args) {
+  const id = args._[0];
+  if (!id) { outputError('Job ID required. Usage: trackly job <id>'); process.exit(1); }
+  if (!getToken()) { outputError('Not logged in. Run: trackly login'); process.exit(1); }
+  try {
+    const result = await apiRequest('GET', `/api/jobscout/jobs/${id}`);
+    if (isJSON()) return console.log(JSON.stringify(result, null, 2));
+    const job = result.job || result;
+    console.log(color('bold', job.title));
+    console.log(`Company: ${color('blue', job.company_name)}`);
+    if (job.location) console.log(`Location: ${job.location}`);
+    if (job.modality) console.log(`Modality: ${color('cyan', job.modality)}`);
+    if (job.url) console.log(`URL: ${color('dim', job.url)}`);
+    if (job.posted_at) console.log(`Posted: ${job.posted_at}`);
+    if (job.description_text) {
+      console.log();
+      console.log(color('bold', 'Description:'));
+      console.log(job.description_text.slice(0, 1000));
+      if (job.description_text.length > 1000) console.log(color('dim', '... (truncated)'));
+    }
+  } catch (e) {
+    outputError(e.error || e.message || 'Failed to fetch job');
+  }
+}
+
+async function cmdCompanies(args) {
+  if (!getToken()) { outputError('Not logged in. Run: trackly login'); process.exit(1); }
+  try {
+    const result = await apiRequest('GET', '/api/jobscout/companies');
+    outputCompanies(result.companies || result.data || []);
+  } catch (e) {
+    outputError(e.error || e.message || 'Failed to fetch companies');
+  }
+}
+
+async function cmdSearch(args) {
+  const query = args._[0];
+  if (!query) { outputError('Search query required. Usage: trackly search "fintech"'); process.exit(1); }
+  if (!getToken()) { outputError('Not logged in. Run: trackly login'); process.exit(1); }
+  try {
+    const result = await apiRequest('GET', `/api/jobscout/companies/search?q=${encodeURIComponent(query)}`);
+    outputCompanies(result.companies || result.results || []);
+  } catch (e) {
+    outputError(e.error || e.message || 'Failed to search');
+  }
+}
+
+async function cmdStats() {
+  if (!getToken()) { outputError('Not logged in. Run: trackly login'); process.exit(1); }
+  try {
+    const result = await apiRequest('GET', '/api/jobscout/me');
+    outputStats(result);
+  } catch (e) {
+    outputError(e.error || e.message || 'Failed to fetch stats');
+  }
+}
+
+async function cmdUpdateStatus(id, action) {
+  if (!id) { outputError(`Job ID required. Usage: trackly ${action} <id>`); process.exit(1); }
+  if (!getToken()) { outputError('Not logged in. Run: trackly login'); process.exit(1); }
+  try {
+    const result = await apiRequest('POST', '/api/jobscout-tracker/status', { jobId: parseInt(id), action });
+    if (isJSON()) return console.log(JSON.stringify(result, null, 2));
+    console.log(color('green', `Job ${id} marked as ${action}d`));
+  } catch (e) {
+    outputError(e.error || e.message || `Failed to ${action} job`);
+  }
+}
+
+async function cmdAsk(args) {
+  const query = args._.join(' ');
+  if (!query) { outputError('Query required. Usage: trackly ask "PM jobs at fintech"'); process.exit(1); }
+  if (!getToken()) { outputError('Not logged in. Run: trackly login'); process.exit(1); }
+  try {
+    const result = await apiRequest('GET', `/api/jobscout/ask?q=${encodeURIComponent(query)}`);
+    if (isJSON()) return console.log(JSON.stringify(result, null, 2));
+    console.log(color('bold', 'Parsed filters:'));
+    for (const [k, v] of Object.entries(result.parsedFilters || {})) {
+      console.log(`  ${k}: ${color('cyan', String(v))}`);
+    }
+    if (result.jobsUrl && result.jobsUrl.startsWith('/api/')) {
+      console.log();
+      console.log(color('dim', `Fetching: ${result.jobsUrl}`));
+      // Auto-fetch jobs with parsed filters
+      const jobsResult = await apiRequest('GET', result.jobsUrl);
+      console.log();
+      outputJobs(jobsResult.jobs || jobsResult.data || []);
+    }
+  } catch (e) {
+    if (e.status === 429) outputError('Daily limit reached (20 natural language queries per day)');
+    else outputError(e.error || e.message || 'Failed to process query');
+  }
+}
+
+async function cmdApiKey(args) {
+  const subcommand = args._[0] || 'create';
+  if (!getToken()) { outputError('Not logged in. Run: trackly login'); process.exit(1); }
+  if (subcommand === 'create') {
+    const name = args.name || 'default';
+    try {
+      const result = await apiRequest('POST', '/api/auth/api-key', { name });
+      if (isJSON()) return console.log(JSON.stringify(result, null, 2));
+      console.log(color('green', 'API key created!'));
+      console.log();
+      console.log(`Key: ${color('bold', result.key)}`);
+      console.log(color('yellow', 'Save this key — it cannot be shown again.'));
+    } catch (e) {
+      outputError(e.error || e.message || 'Failed to create API key');
+    }
+  } else if (subcommand === 'list') {
+    try {
+      const result = await apiRequest('GET', '/api/auth/api-keys');
+      if (isJSON()) return console.log(JSON.stringify(result.keys, null, 2));
+      for (const key of (result.keys || [])) {
+        console.log(`${color('bold', key.key_prefix + '...')} — ${key.name} (created ${key.created_at})`);
+      }
+    } catch (e) {
+      outputError(e.error || e.message || 'Failed to list keys');
+    }
+  }
+}
+
+async function cmdMcp() {
+  // Delegate to MCP server
+  require('../mcp/server');
+}
+
+function showHelp() {
+  console.log(`
+${color('bold', 'trackly')} — Trackly job tracker CLI + MCP server
+
+${color('bold', 'Usage:')}
+  trackly <command> [options]
+
+${color('bold', 'Commands:')}
+  ${color('cyan', 'login')}              Authenticate via Google OAuth
+  ${color('cyan', 'logout')}             Clear credentials
+  ${color('cyan', 'whoami')}             Show current user
+  ${color('cyan', 'jobs')}               List jobs (--function, --location, --modality, --status, --sort, --limit, --offset)
+  ${color('cyan', 'job <id>')}           Get full job detail
+  ${color('cyan', 'companies')}          List companies
+  ${color('cyan', 'search <query>')}     Semantic company search
+  ${color('cyan', 'stats')}              Show metrics dashboard
+  ${color('cyan', 'apply <id>')}         Mark job as applied
+  ${color('cyan', 'save <id>')}          Save a job
+  ${color('cyan', 'dismiss <id>')}       Dismiss a job
+  ${color('cyan', 'ask "query"')}        Natural language job search (20/day)
+  ${color('cyan', 'api-key create')}     Generate an API key
+  ${color('cyan', 'api-key list')}       List your API keys
+  ${color('cyan', 'mcp')}               Start MCP server (for Claude Code)
+
+${color('bold', 'Flags:')}
+  --json              Force JSON output
+  --help              Show this help
+
+${color('bold', 'MCP Setup (Claude Code):')}
+  Add to ~/.claude/settings.json:
+  {
+    "mcpServers": {
+      "trackly": {
+        "command": "trackly",
+        "args": ["mcp"]
+      }
+    }
+  }
+`);
+}
+
+// -- Main --
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (!args.command || args.help || args.h) { showHelp(); process.exit(0); }
+
+  switch (args.command) {
+    case 'login': await cmdLogin(); break;
+    case 'logout': await cmdLogout(); break;
+    case 'whoami': await cmdWhoami(); break;
+    case 'jobs': await cmdJobs(args); break;
+    case 'job': await cmdJob(args); break;
+    case 'companies': await cmdCompanies(args); break;
+    case 'search': await cmdSearch(args); break;
+    case 'stats': await cmdStats(); break;
+    case 'apply': await cmdUpdateStatus(args._[0], 'applied'); break;
+    case 'save': await cmdUpdateStatus(args._[0], 'saved'); break;
+    case 'dismiss': await cmdUpdateStatus(args._[0], 'dismissed'); break;
+    case 'ask': await cmdAsk(args); break;
+    case 'api-key': await cmdApiKey(args); break;
+    case 'mcp': await cmdMcp(); break;
+    default:
+      outputError(`Unknown command: ${args.command}`);
+      showHelp();
+      process.exit(1);
+  }
+}
+
+main().catch(e => {
+  outputError(e.message || String(e));
+  process.exit(1);
+});

package/docs/trackly-tools.md

@@ -0,0 +1,31 @@
+## Trackly Job Tracker (MCP)
+
+Trackly MCP server provides job search and tracking tools. Add to your Claude Code settings:
+
+```json
+{
+  "mcpServers": {
+    "trackly": {
+      "command": "trackly",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+### Available Tools
+
+- **trackly_search_jobs** — Search/filter jobs by function, location, modality, keywords
+- **trackly_get_job** — Get full job details by ID
+- **trackly_search_companies** — Semantic company search
+- **trackly_list_companies** — List all tracked companies with job counts
+- **trackly_get_stats** — Job tracker metrics dashboard
+- **trackly_update_status** — Mark a job as applied, saved, or dismissed
+- **trackly_ask** — Natural language job search (20/day limit)
+
+### Example Prompts
+
+- "Find me PM jobs at fintech companies"
+- "What remote engineering roles are available?"
+- "Show me jobs at Stripe"
+- "Mark job 1234 as applied"

package/lib/client.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.trackly');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const DEFAULT_BASE_URL = 'https://closeai.mba';
+
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    }
+  } catch (e) {}
+  return {};
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+function clearConfig() {
+  try { fs.unlinkSync(CONFIG_FILE); } catch (e) {}
+}
+
+function getBaseUrl() {
+  return loadConfig().baseUrl || DEFAULT_BASE_URL;
+}
+
+function getToken() {
+  return loadConfig().token || null;
+}
+
+function getRefreshToken() {
+  return loadConfig().refreshToken || null;
+}
+
+async function refreshAccessToken() {
+  const rt = getRefreshToken();
+  if (!rt) return null;
+  const baseUrl = getBaseUrl();
+  if (!baseUrl.startsWith('https://') && !baseUrl.startsWith('http://localhost')) {
+    console.error('Warning: Refusing to send refresh token over insecure connection');
+    return null;
+  }
+  try {
+    const result = await apiRequest('POST', '/api/auth/refresh', { refreshToken: rt }, true);
+    if (result.success && result.token) {
+      const config = loadConfig();
+      config.token = result.token;
+      if (result.refreshToken) config.refreshToken = result.refreshToken;
+      saveConfig(config);
+      return result.token;
+    }
+  } catch (e) {}
+  return null;
+}
+
+function apiRequest(method, endpoint, data = null, skipAuth = false, _isRetry = false) {
+  return new Promise((resolve, reject) => {
+    const baseUrl = getBaseUrl();
+    const url = new URL(endpoint, baseUrl);
+    const isHttps = url.protocol === 'https:';
+    const lib = isHttps ? https : http;
+
+    const headers = {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      'User-Agent': 'trackly-cli/0.1.0',
+    };
+
+    if (!skipAuth) {
+      const token = getToken();
+      if (token) headers['Authorization'] = `Bearer ${token}`;
+    }
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method,
+      headers,
+    };
+
+    const req = lib.request(options, (res) => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', async () => {
+        let json;
+        try { json = JSON.parse(body); } catch { json = { raw: body }; }
+
+        if (res.statusCode === 401 && !skipAuth && !_isRetry) {
+          // Try token refresh (once only)
+          const newToken = await refreshAccessToken();
+          if (newToken) {
+            try {
+              const retried = await apiRequest(method, endpoint, data, false, true);
+              return resolve(retried);
+            } catch (e) { return reject(e); }
+          }
+        }
+
+        if (res.statusCode >= 400) {
+          reject({ status: res.statusCode, ...json });
+        } else {
+          resolve(json);
+        }
+      });
+    });
+
+    req.on('error', reject);
+    if (data) req.write(JSON.stringify(data));
+    req.end();
+  });
+}
+
+module.exports = { loadConfig, saveConfig, clearConfig, apiRequest, getToken, CONFIG_DIR, CONFIG_FILE };

package/lib/formatters.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const c = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  green: '\x1b[32m', yellow: '\x1b[33m', blue: '\x1b[34m',
+  magenta: '\x1b[35m', cyan: '\x1b[36m', red: '\x1b[31m',
+};
+
+function color(name, text) {
+  return `${c[name] || ''}${text}${c.reset}`;
+}
+
+function isJSON() {
+  return !process.stdout.isTTY || process.argv.includes('--json');
+}
+
+function outputJobs(jobs) {
+  if (isJSON()) return console.log(JSON.stringify(jobs, null, 2));
+  if (!jobs || jobs.length === 0) {
+    console.log(color('dim', 'No jobs found.'));
+    return;
+  }
+  for (const job of jobs) {
+    const modality = job.modality ? color('cyan', `[${job.modality}]`) : '';
+    const location = job.location ? color('dim', job.location) : '';
+    console.log(`${color('bold', job.title)} ${modality}`);
+    console.log(`  ${color('blue', job.company_name)} | ${location}`);
+    console.log(`  ID: ${color('dim', job.id)} | Posted: ${color('dim', job.posted_at || job.first_seen_at || 'unknown')}`);
+    if (job.url) console.log(`  ${color('dim', job.url)}`);
+    console.log();
+  }
+}
+
+function outputCompanies(companies) {
+  if (isJSON()) return console.log(JSON.stringify(companies, null, 2));
+  if (!companies || companies.length === 0) {
+    console.log(color('dim', 'No companies found.'));
+    return;
+  }
+  for (const co of companies) {
+    const count = co.active_jobs_count || co.job_count || 0;
+    console.log(`${color('bold', co.name)} — ${color('cyan', count + ' jobs')}`);
+    if (co.domain) console.log(`  ${color('dim', co.domain)}`);
+    console.log();
+  }
+}
+
+function outputStats(stats) {
+  if (isJSON()) return console.log(JSON.stringify(stats, null, 2));
+  console.log(color('bold', 'Trackly Stats'));
+  console.log();
+  if (stats.totalJobs !== undefined) console.log(`Total Jobs: ${color('cyan', stats.totalJobs)}`);
+  if (stats.totalCompanies !== undefined) console.log(`Companies: ${color('cyan', stats.totalCompanies)}`);
+  if (stats.appliedCount !== undefined) console.log(`Applied: ${color('green', stats.appliedCount)}`);
+  if (stats.savedCount !== undefined) console.log(`Saved: ${color('yellow', stats.savedCount)}`);
+  // Print any other keys
+  for (const [k, v] of Object.entries(stats)) {
+    if (!['totalJobs', 'totalCompanies', 'appliedCount', 'savedCount'].includes(k)) {
+      console.log(`${k}: ${color('dim', JSON.stringify(v))}`);
+    }
+  }
+}
+
+function outputError(msg) {
+  console.error(color('red', `Error: ${msg}`));
+}
+
+module.exports = { color, isJSON, outputJobs, outputCompanies, outputStats, outputError };

package/mcp/server.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { z } = require('zod');
+const { apiRequest, getToken } = require('../lib/client');
+
+const server = new McpServer({
+  name: 'trackly',
+  version: '0.1.0',
+});
+
+// Tool: Search/filter jobs
+server.tool(
+  'trackly_search_jobs',
+  'Search and filter job postings. Returns matching jobs with title, company, location, modality.',
+  {
+    function: z.string().optional().describe('Job function filter: product_management, engineering, design, data_science, marketing, sales, finance, operations, legal, hr, other'),
+    location: z.string().optional().describe('Location filter (city or state)'),
+    modality: z.string().optional().describe('Work modality: remote, hybrid, onsite'),
+    status: z.string().optional().describe('Application status: new, saved, applied, dismissed'),
+    sort: z.string().optional().describe('Sort order: newest, oldest, company'),
+    limit: z.number().optional().describe('Max results (default 20, max 50)'),
+    offset: z.number().optional().describe('Pagination offset'),
+    keywords: z.string().optional().describe('Keyword search in title/description'),
+  },
+  async (params) => {
+    const qs = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== undefined && v !== null) qs.set(k, String(v));
+    }
+    try {
+      const result = await apiRequest('GET', `/api/jobscout/jobs?${qs.toString()}`);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (e) {
+      return { content: [{ type: 'text', text: JSON.stringify({ error: e.error || e.message }) }], isError: true };
+    }
+  }
+);
+
+// Tool: Get job detail
+server.tool(
+  'trackly_get_job',
+  'Get full details for a specific job posting including description.',
+  {
+    id: z.number().describe('Job posting ID'),
+  },
+  async ({ id }) => {
+    try {
+      const result = await apiRequest('GET', `/api/jobscout/jobs/${id}`);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (e) {
+      return { content: [{ type: 'text', text: JSON.stringify({ error: e.error || e.message }) }], isError: true };
+    }
+  }
+);
+
+// Tool: Search companies
+server.tool(
+  'trackly_search_companies',
+  'Semantic search for companies by name, domain, or keywords.',
+  {
+    query: z.string().describe('Search query'),
+    limit: z.number().optional().describe('Max results (default 10)'),
+  },
+  async ({ query, limit }) => {
+    const qs = new URLSearchParams({ q: query });
+    if (limit) qs.set('limit', String(limit));
+    try {
+      const result = await apiRequest('GET', `/api/jobscout/companies/search?${qs.toString()}`);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (e) {
+      return { content: [{ type: 'text', text: JSON.stringify({ error: e.error || e.message }) }], isError: true };
+    }
+  }
+);
+
+// Tool: List companies
+server.tool(
+  'trackly_list_companies',
+  'List all tracked companies with their active job counts.',
+  {
+    limit: z.number().optional().describe('Max results'),
+    offset: z.number().optional().describe('Pagination offset'),
+  },
+  async ({ limit, offset }) => {
+    const qs = new URLSearchParams();
+    if (limit) qs.set('limit', String(limit));
+    if (offset) qs.set('offset', String(offset));
+    try {
+      const result = await apiRequest('GET', `/api/jobscout/companies?${qs.toString()}`);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (e) {
+      return { content: [{ type: 'text', text: JSON.stringify({ error: e.error || e.message }) }], isError: true };
+    }
+  }
+);
+
+// Tool: Get stats
+server.tool(
+  'trackly_get_stats',
+  'Get job tracker metrics: total jobs, companies, application status counts.',
+  {},
+  async () => {
+    try {
+      const result = await apiRequest('GET', '/api/jobscout/me');
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (e) {
+      return { content: [{ type: 'text', text: JSON.stringify({ error: e.error || e.message }) }], isError: true };
+    }
+  }
+);
+
+// Tool: Update job status
+server.tool(
+  'trackly_update_status',
+  'Update a job application status (apply, save, or dismiss).',
+  {
+    id: z.number().describe('Job posting ID'),
+    action: z.enum(['applied', 'saved', 'dismissed']).describe('Status action'),
+  },
+  async ({ id, action }) => {
+    try {
+      const result = await apiRequest('POST', '/api/jobscout-tracker/status', { jobId: id, action });
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (e) {
+      return { content: [{ type: 'text', text: JSON.stringify({ error: e.error || e.message }) }], isError: true };
+    }
+  }
+);
+
+// Tool: Natural language search
+server.tool(
+  'trackly_ask',
+  'Natural language job search. Describe what you are looking for and the AI parses it into structured filters. Limited to 20 queries per day.',
+  {
+    query: z.string().describe('Natural language search query, e.g. "PM jobs at fintech companies in SF"'),
+  },
+  async ({ query }) => {
+    try {
+      const askResult = await apiRequest('GET', `/api/jobscout/ask?q=${encodeURIComponent(query)}`);
+      // Auto-fetch jobs with parsed filters
+      if (askResult.jobsUrl && askResult.jobsUrl.startsWith('/api/')) {
+        const jobsResult = await apiRequest('GET', askResult.jobsUrl);
+        return { content: [{ type: 'text', text: JSON.stringify({ ...askResult, jobs: jobsResult.jobs || jobsResult.data || [] }, null, 2) }] };
+      }
+      return { content: [{ type: 'text', text: JSON.stringify(askResult, null, 2) }] };
+    } catch (e) {
+      return { content: [{ type: 'text', text: JSON.stringify({ error: e.error || e.message }) }], isError: true };
+    }
+  }
+);
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((e) => {
+  console.error('MCP server error:', e);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "trackly-cli",
+  "version": "0.1.0",
+  "description": "Trackly job tracker CLI + MCP server for AI agents",
+  "bin": {
+    "trackly": "./bin/trackly"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "mcp/",
+    "docs/",
+    "README.md"
+  ],
+  "keywords": [
+    "trackly",
+    "jobs",
+    "job-tracker",
+    "mcp",
+    "cli",
+    "claude-code",
+    "ai-agent"
+  ],
+  "author": "Kevin Astuhuaman <kevin.astuhuaman.flores@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kevinastuhuaman/trackly-cli"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.23.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}