bitcompass 0.1.0

package/README.md

@@ -0,0 +1,90 @@
+# BitCompass CLI
+
+CLI for rules, solutions, and MCP server. Same backend as the webapp (Supabase).
+
+## Install
+
+```bash
+npm install -g bitcompass
+```
+
+Or run without installing:
+
+```bash
+npx bitcompass --help
+```
+
+Package: [npmjs.com/package/bitcompass](https://www.npmjs.com/package/bitcompass)
+
+## Setup
+
+1. Configure Supabase (required for login and API):
+   - `bitcompass config set supabaseUrl https://YOUR_PROJECT.supabase.co`
+   - `bitcompass config set supabaseAnonKey YOUR_ANON_KEY`
+   - Or set `BITCOMPASS_SUPABASE_URL` and `BITCOMPASS_SUPABASE_ANON_KEY`
+2. Log in: `bitcompass login` (opens browser)
+
+## Commands
+
+- `bitcompass login` – Google login (opens browser)
+- `bitcompass logout` – Remove credentials
+- `bitcompass whoami` – Show current user
+- `bitcompass rules search [query]` – Search rules
+- `bitcompass rules list` – List rules
+- `bitcompass rules pull [id]` – Pull rule to file
+- `bitcompass rules push [file]` – Push rule (or interactive)
+- `bitcompass solutions search|pull|push` – Same for solutions
+- `bitcompass mcp start` – Start MCP server (stdio) for Cursor/IDEs
+- `bitcompass mcp status` – Show MCP login status
+- `bitcompass config` – List config; `config set/get` for values
+
+## MCP
+
+### Cursor (global install)
+
+If you installed via `npm install -g bitcompass`, add this to Cursor’s MCP config:
+
+**Cursor:** Settings → Features → MCP → Edit config (or open `~/.cursor/mcp.json`).
+
+Add the `bitcompass` entry under `mcpServers`:
+
+```json
+{
+  "mcpServers": {
+    "bitcompass": {
+      "type": "stdio",
+      "command": "bitcompass",
+      "args": ["mcp", "start"],
+      "env": {
+        "BITCOMPASS_CONFIG_DIR": "~/.bitcompass"
+      }
+    }
+  }
+}
+```
+
+Replace `~` with your full home path if your environment doesn’t expand it. Run `bitcompass login` before using MCP.
+
+### Development (this repo)
+
+This repo includes **`.cursor/mcp.json`** so Cursor points at the local CLI when the project is open. Build and log in:
+
+```bash
+cd packages/bitcompass-cli && npm run build && bitcompass login
+```
+
+**Manual (local path):** Settings → MCP → stdio, Command **node**, Args **path/to/packages/bitcompass-cli/dist/index.js** **mcp** **start**. Optionally set env or envFile to the CLI `.env`.
+
+Tools: `search-rules`, `search-solutions`, `post-rules`. Prompts: `share_new_rule`, `share_problem_solution`.
+
+## Publish (maintainers)
+
+From the CLI package directory:
+
+```bash
+cd packages/bitcompass-cli
+npm run build
+npm publish
+```
+
+For a scoped package use `npm publish --access public`.

package/dist/api/client.d.ts

@@ -0,0 +1,12 @@
+import { type SupabaseClient } from '@supabase/supabase-js';
+import type { Rule, RuleInsert } from '../types.js';
+export declare const getSupabaseClient: () => SupabaseClient | null;
+export declare const fetchRules: (kind?: "rule" | "solution") => Promise<Rule[]>;
+export declare const searchRules: (queryText: string, options?: {
+    kind?: "rule" | "solution";
+    limit?: number;
+}) => Promise<Rule[]>;
+export declare const getRuleById: (id: string) => Promise<Rule | null>;
+export declare const insertRule: (rule: RuleInsert) => Promise<Rule>;
+export declare const updateRule: (id: string, updates: Partial<RuleInsert>) => Promise<Rule>;
+export declare const deleteRule: (id: string) => Promise<void>;

package/dist/api/client.js

@@ -0,0 +1,89 @@
+import { createClient } from '@supabase/supabase-js';
+import { loadConfig, loadCredentials } from '../auth/config.js';
+export const getSupabaseClient = () => {
+    const config = loadConfig();
+    const creds = loadCredentials();
+    const url = config.supabaseUrl ?? process.env.BITCOMPASS_SUPABASE_URL;
+    const key = config.supabaseAnonKey ?? process.env.BITCOMPASS_SUPABASE_ANON_KEY;
+    if (!url || !key) {
+        return null;
+    }
+    const accessToken = creds?.access_token;
+    const client = createClient(url, key, {
+        global: accessToken
+            ? { headers: { Authorization: `Bearer ${accessToken}` } }
+            : undefined,
+    });
+    return client;
+};
+export const fetchRules = async (kind) => {
+    const client = getSupabaseClient();
+    if (!client) {
+        throw new Error('Supabase not configured. Set BITCOMPASS_SUPABASE_URL and BITCOMPASS_SUPABASE_ANON_KEY or run bitcompass config.');
+    }
+    let query = client.from('rules').select('*').order('created_at', { ascending: false });
+    if (kind) {
+        query = query.eq('kind', kind);
+    }
+    const { data, error } = await query;
+    if (error)
+        throw new Error(error.message);
+    return (data ?? []);
+};
+export const searchRules = async (queryText, options = {}) => {
+    const client = getSupabaseClient();
+    if (!client) {
+        throw new Error('Supabase not configured.');
+    }
+    let query = client
+        .from('rules')
+        .select('*')
+        .or(`title.ilike.%${queryText}%,description.ilike.%${queryText}%,body.ilike.%${queryText}%`)
+        .order('created_at', { ascending: false })
+        .limit(options.limit ?? 20);
+    if (options.kind) {
+        query = query.eq('kind', options.kind);
+    }
+    const { data, error } = await query;
+    if (error)
+        throw new Error(error.message);
+    return (data ?? []);
+};
+export const getRuleById = async (id) => {
+    const client = getSupabaseClient();
+    if (!client)
+        throw new Error('Supabase not configured.');
+    const { data, error } = await client.from('rules').select('*').eq('id', id).single();
+    if (error) {
+        if (error.code === 'PGRST116')
+            return null;
+        throw new Error(error.message);
+    }
+    return data;
+};
+export const insertRule = async (rule) => {
+    const client = getSupabaseClient();
+    if (!client)
+        throw new Error('Supabase not configured.');
+    const { data, error } = await client.from('rules').insert(rule).select().single();
+    if (error)
+        throw new Error(error.message);
+    return data;
+};
+export const updateRule = async (id, updates) => {
+    const client = getSupabaseClient();
+    if (!client)
+        throw new Error('Supabase not configured.');
+    const { data, error } = await client.from('rules').update(updates).eq('id', id).select().single();
+    if (error)
+        throw new Error(error.message);
+    return data;
+};
+export const deleteRule = async (id) => {
+    const client = getSupabaseClient();
+    if (!client)
+        throw new Error('Supabase not configured.');
+    const { error } = await client.from('rules').delete().eq('id', id);
+    if (error)
+        throw new Error(error.message);
+};

package/dist/auth/config.d.ts

@@ -0,0 +1,9 @@
+import type { BitcompassConfig, StoredCredentials } from '../types.js';
+export declare const getConfigDir: () => string;
+export declare const getTokenFilePath: () => string;
+export declare const loadConfig: () => BitcompassConfig;
+export declare const saveConfig: (config: BitcompassConfig) => void;
+export declare const loadCredentials: () => StoredCredentials | null;
+export declare const saveCredentials: (creds: StoredCredentials) => void;
+export declare const clearCredentials: () => void;
+export declare const isLoggedIn: () => boolean;

package/dist/auth/config.js

@@ -0,0 +1,81 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const getDir = () => {
+    const base = process.env.BITCOMPASS_CONFIG_DIR ?? join(homedir(), '.bitcompass');
+    return base;
+};
+let _dir = null;
+const getDirCached = () => {
+    if (_dir === null)
+        _dir = getDir();
+    return _dir;
+};
+const CONFIG_FILE = () => join(getDirCached(), 'config.json');
+const TOKEN_FILE = () => join(getDirCached(), 'token.json');
+const ensureDir = () => {
+    const dir = getDirCached();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { mode: 0o700, recursive: true });
+    }
+};
+export const getConfigDir = () => {
+    ensureDir();
+    return getDirCached();
+};
+export const getTokenFilePath = () => TOKEN_FILE();
+export const loadConfig = () => {
+    ensureDir();
+    const path = CONFIG_FILE();
+    if (!existsSync(path)) {
+        return {};
+    }
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+};
+export const saveConfig = (config) => {
+    ensureDir();
+    writeFileSync(CONFIG_FILE(), JSON.stringify(config, null, 2), { mode: 0o600 });
+};
+export const loadCredentials = () => {
+    ensureDir();
+    const path = TOKEN_FILE();
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+};
+export const saveCredentials = (creds) => {
+    ensureDir();
+    const path = TOKEN_FILE();
+    writeFileSync(path, JSON.stringify(creds, null, 0), { mode: 0o600 });
+    if (!existsSync(path)) {
+        throw new Error(`Token file was not created at ${path}`);
+    }
+};
+export const clearCredentials = () => {
+    const path = TOKEN_FILE();
+    if (existsSync(path)) {
+        try {
+            writeFileSync(path, '{}', { mode: 0o600 });
+        }
+        catch {
+            // ignore
+        }
+    }
+};
+export const isLoggedIn = () => {
+    const creds = loadCredentials();
+    return Boolean(creds?.access_token);
+};

package/dist/commands/config-cmd.d.ts

@@ -0,0 +1,3 @@
+export declare const runConfigList: () => void;
+export declare const runConfigSet: (key: string, value: string) => void;
+export declare const runConfigGet: (key: string) => void;

package/dist/commands/config-cmd.js

@@ -0,0 +1,33 @@
+import { loadConfig, saveConfig, getConfigDir } from '../auth/config.js';
+import chalk from 'chalk';
+const CONFIG_KEYS = ['supabaseUrl', 'supabaseAnonKey', 'apiUrl'];
+export const runConfigList = () => {
+    const dir = getConfigDir();
+    const config = loadConfig();
+    console.log(chalk.dim('Config dir:'), dir);
+    console.log('');
+    CONFIG_KEYS.forEach((key) => {
+        const val = config[key] ?? process.env[`BITCOMPASS_${key.toUpperCase()}`] ?? '(not set)';
+        const display = typeof val === 'string' && val.length > 40 ? val.slice(0, 40) + '…' : val;
+        console.log(`  ${key}: ${display}`);
+    });
+};
+export const runConfigSet = (key, value) => {
+    const config = loadConfig();
+    if (!CONFIG_KEYS.includes(key)) {
+        console.error(chalk.red('Unknown key. Use one of:'), CONFIG_KEYS.join(', '));
+        process.exit(1);
+    }
+    config[key] = value;
+    saveConfig(config);
+    console.log(chalk.green('Updated'), key);
+};
+export const runConfigGet = (key) => {
+    const config = loadConfig();
+    if (!CONFIG_KEYS.includes(key)) {
+        console.error(chalk.red('Unknown key.'));
+        process.exit(1);
+    }
+    const val = config[key] ?? process.env[`BITCOMPASS_${key.toUpperCase()}`];
+    console.log(val ?? '');
+};

package/dist/commands/login.d.ts

@@ -0,0 +1 @@
+export declare const runLogin: () => Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,146 @@
+import { createClient } from '@supabase/supabase-js';
+import chalk from 'chalk';
+import { createServer } from 'http';
+import open from 'open';
+import ora from 'ora';
+import { getTokenFilePath, loadConfig, saveCredentials } from '../auth/config.js';
+const CALLBACK_PORT = 38473;
+const createInMemoryStorage = () => {
+    const store = new Map();
+    return {
+        getItem: async (key) => store.get(key) ?? null,
+        setItem: async (key, value) => {
+            store.set(key, value);
+        },
+        removeItem: async (key) => {
+            store.delete(key);
+        },
+    };
+};
+export const runLogin = async () => {
+    const config = loadConfig();
+    const url = config.supabaseUrl ?? process.env.BITCOMPASS_SUPABASE_URL;
+    const anonKey = config.supabaseAnonKey ?? process.env.BITCOMPASS_SUPABASE_ANON_KEY;
+    if (!url || !anonKey) {
+        console.error(chalk.red('Supabase not configured. Set supabaseUrl and supabaseAnonKey:\n  bitcompass config set supabaseUrl https://YOUR_PROJECT.supabase.co\n  bitcompass config set supabaseAnonKey YOUR_ANON_KEY\nOr set BITCOMPASS_SUPABASE_URL and BITCOMPASS_SUPABASE_ANON_KEY.'));
+        process.exit(1);
+    }
+    const redirectTo = `http://127.0.0.1:${CALLBACK_PORT}/callback`;
+    const storage = createInMemoryStorage();
+    const supabase = createClient(url, anonKey, {
+        auth: {
+            flowType: 'pkce',
+            storage,
+            detectSessionInUrl: false,
+        },
+    });
+    const spinner = ora('Opening browser for Google login…').start();
+    return new Promise((resolve, reject) => {
+        const server = createServer(async (req, res) => {
+            const u = new URL(req.url ?? '/', `http://127.0.0.1:${CALLBACK_PORT}`);
+            if (u.pathname === '/callback') {
+                const code = u.searchParams.get('code');
+                const errorDesc = u.searchParams.get('error_description');
+                if (errorDesc) {
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(`<!DOCTYPE html><html><body><p>Login failed: ${errorDesc}</p></body></html>`);
+                    spinner.fail(chalk.red('Login failed: ' + errorDesc));
+                    server.close();
+                    reject(new Error(errorDesc));
+                    return;
+                }
+                if (!code) {
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end('<!DOCTYPE html><html><body><p>No authorization code in URL. Try again.</p></body></html>');
+                    spinner.fail(chalk.red('No code received. Try again.'));
+                    server.close();
+                    reject(new Error('No code'));
+                    return;
+                }
+                try {
+                    const { data, error } = await supabase.auth.exchangeCodeForSession(code);
+                    if (error) {
+                        res.writeHead(200, { 'Content-Type': 'text/html' });
+                        res.end(`<!DOCTYPE html><html><body><p>Exchange failed: ${error.message}</p></body></html>`);
+                        spinner.fail(chalk.red('Login failed: ' + error.message));
+                        server.close();
+                        reject(error);
+                        return;
+                    }
+                    const session = data?.session;
+                    if (!session?.access_token) {
+                        res.writeHead(200, { 'Content-Type': 'text/html' });
+                        res.end('<!DOCTYPE html><html><body><p>No session received.</p></body></html>');
+                        spinner.fail(chalk.red('No session.'));
+                        server.close();
+                        reject(new Error('No session'));
+                        return;
+                    }
+                    const creds = {
+                        access_token: session.access_token,
+                        refresh_token: session.refresh_token ?? '',
+                        user: session.user ? { email: session.user.email ?? undefined } : {},
+                    };
+                    const tokenPath = getTokenFilePath();
+                    saveCredentials(creds);
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end('<!DOCTYPE html><html><body><p>Logged in. You can close this window.</p></body></html>');
+                    spinner.succeed(chalk.green('Logged in successfully.'));
+                    console.log(chalk.dim('Credentials saved to:'), tokenPath);
+                    server.close();
+                    resolve();
+                }
+                catch (e) {
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(`<!DOCTYPE html><html><body><p>Error: ${e instanceof Error ? e.message : String(e)}</p></body></html>`);
+                    spinner.fail('Login failed.');
+                    console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+                    server.close();
+                    reject(e);
+                }
+                return;
+            }
+            res.writeHead(404);
+            res.end();
+        });
+        server.listen(CALLBACK_PORT, '127.0.0.1', async () => {
+            spinner.text = 'Waiting for login…';
+            try {
+                const { data, error } = await supabase.auth.signInWithOAuth({
+                    provider: 'google',
+                    options: {
+                        redirectTo,
+                        scopes: 'openid email profile',
+                        queryParams: { access_type: 'offline', prompt: 'consent' },
+                        skipBrowserRedirect: true,
+                    },
+                });
+                if (error) {
+                    spinner.fail(chalk.red('Login failed: ' + error.message));
+                    server.close();
+                    reject(error);
+                    return;
+                }
+                const authUrl = data?.url;
+                if (!authUrl) {
+                    spinner.fail(chalk.red('No auth URL returned.'));
+                    server.close();
+                    reject(new Error('No auth URL'));
+                    return;
+                }
+                open(authUrl).catch(() => {
+                    console.log(chalk.yellow('Open this URL in your browser:'), authUrl);
+                });
+            }
+            catch (e) {
+                spinner.fail('Login failed.');
+                server.close();
+                reject(e);
+            }
+        });
+        server.on('error', (err) => {
+            spinner.fail('Could not start callback server.');
+            reject(err);
+        });
+    });
+};

package/dist/commands/logout.d.ts

@@ -0,0 +1 @@
+export declare const runLogout: () => void;

package/dist/commands/logout.js

@@ -0,0 +1,6 @@
+import { clearCredentials } from '../auth/config.js';
+import chalk from 'chalk';
+export const runLogout = () => {
+    clearCredentials();
+    console.log(chalk.green('Logged out.'));
+};

package/dist/commands/mcp.d.ts

@@ -0,0 +1,2 @@
+export declare const runMcpStart: () => Promise<void>;
+export declare const runMcpStatus: () => void;

package/dist/commands/mcp.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+import { isLoggedIn } from '../auth/config.js';
+import { startMcpServer } from '../mcp/server.js';
+export const runMcpStart = async () => {
+    if (!isLoggedIn()) {
+        console.error(chalk.red('Not logged in. Run bitcompass login first.'));
+        process.exit(1);
+    }
+    await startMcpServer();
+};
+export const runMcpStatus = () => {
+    if (isLoggedIn()) {
+        console.log(chalk.green('MCP: ready (logged in)'));
+    }
+    else {
+        console.log(chalk.yellow('MCP: not logged in. Run bitcompass login.'));
+    }
+};

package/dist/commands/rules.d.ts

@@ -0,0 +1,4 @@
+export declare const runRulesSearch: (query?: string) => Promise<void>;
+export declare const runRulesList: () => Promise<void>;
+export declare const runRulesPull: (id?: string) => Promise<void>;
+export declare const runRulesPush: (file?: string) => Promise<void>;

package/dist/commands/rules.js

@@ -0,0 +1,105 @@
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import { loadCredentials } from '../auth/config.js';
+import { searchRules, fetchRules, getRuleById, insertRule } from '../api/client.js';
+export const runRulesSearch = async (query) => {
+    if (!loadCredentials()) {
+        console.error(chalk.red('Not logged in. Run bitcompass login.'));
+        process.exit(1);
+    }
+    const q = query ?? (await inquirer.prompt([{ name: 'q', message: 'Search query', type: 'input' }])).q;
+    const spinner = ora('Searching rules…').start();
+    const list = await searchRules(q, { kind: 'rule', limit: 20 });
+    spinner.stop();
+    if (list.length === 0) {
+        console.log(chalk.yellow('No rules found.'));
+        return;
+    }
+    const choice = await inquirer.prompt([
+        {
+            name: 'id',
+            message: 'Select a rule',
+            type: 'list',
+            choices: list.map((r) => ({ name: `${r.title} (${r.id})`, value: r.id })),
+        },
+    ]);
+    const rule = await getRuleById(choice.id);
+    if (rule) {
+        console.log(chalk.cyan(rule.title));
+        console.log(rule.body);
+    }
+};
+export const runRulesList = async () => {
+    if (!loadCredentials()) {
+        console.error(chalk.red('Not logged in. Run bitcompass login.'));
+        process.exit(1);
+    }
+    const spinner = ora('Loading rules…').start();
+    const list = await fetchRules('rule');
+    spinner.stop();
+    list.forEach((r) => console.log(`${chalk.cyan(r.title)}  ${chalk.dim(r.id)}`));
+    if (list.length === 0)
+        console.log(chalk.yellow('No rules yet.'));
+};
+export const runRulesPull = async (id) => {
+    if (!loadCredentials()) {
+        console.error(chalk.red('Not logged in. Run bitcompass login.'));
+        process.exit(1);
+    }
+    let targetId = id;
+    if (!targetId) {
+        const spinner = ora('Loading rules…').start();
+        const list = await fetchRules('rule');
+        spinner.stop();
+        if (list.length === 0) {
+            console.log(chalk.yellow('No rules to pull.'));
+            return;
+        }
+        const choice = await inquirer.prompt([
+            { name: 'id', message: 'Select rule', type: 'list', choices: list.map((r) => ({ name: r.title, value: r.id })) },
+        ]);
+        targetId = choice.id;
+    }
+    const rule = await getRuleById(targetId);
+    if (!rule) {
+        console.error(chalk.red('Rule not found.'));
+        process.exit(1);
+    }
+    const filename = `rule-${rule.id}.md`;
+    const content = `# ${rule.title}\n\n${rule.description}\n\n${rule.body}\n`;
+    writeFileSync(filename, content);
+    console.log(chalk.green('Wrote'), filename);
+};
+export const runRulesPush = async (file) => {
+    if (!loadCredentials()) {
+        console.error(chalk.red('Not logged in. Run bitcompass login.'));
+        process.exit(1);
+    }
+    let payload;
+    if (file) {
+        const { readFileSync } = await import('fs');
+        const raw = readFileSync(file, 'utf-8');
+        try {
+            payload = JSON.parse(raw);
+        }
+        catch {
+            const lines = raw.split('\n');
+            const title = lines[0].replace(/^#\s*/, '') || 'Untitled';
+            payload = { kind: 'rule', title, description: '', body: raw };
+        }
+    }
+    else {
+        const answers = await inquirer.prompt([
+            { name: 'title', message: 'Rule title', type: 'input', default: 'Untitled' },
+            { name: 'description', message: 'Description', type: 'input', default: '' },
+            { name: 'body', message: 'Rule content', type: 'editor', default: '' },
+        ]);
+        payload = { kind: 'rule', title: answers.title, description: answers.description, body: answers.body };
+    }
+    const spinner = ora('Publishing rule…').start();
+    const created = await insertRule(payload);
+    spinner.succeed(chalk.green('Published rule ') + created.id);
+    console.log(chalk.dim(created.title));
+};

package/dist/commands/solutions.d.ts

@@ -0,0 +1,3 @@
+export declare const runSolutionsSearch: (query?: string) => Promise<void>;
+export declare const runSolutionsPull: (id?: string) => Promise<void>;
+export declare const runSolutionsPush: (file?: string) => Promise<void>;

package/dist/commands/solutions.js

@@ -0,0 +1,94 @@
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import { loadCredentials } from '../auth/config.js';
+import { searchRules, fetchRules, getRuleById, insertRule } from '../api/client.js';
+export const runSolutionsSearch = async (query) => {
+    if (!loadCredentials()) {
+        console.error(chalk.red('Not logged in. Run bitcompass login.'));
+        process.exit(1);
+    }
+    const q = query ?? (await inquirer.prompt([{ name: 'q', message: 'Search query', type: 'input' }])).q;
+    const spinner = ora('Searching solutions…').start();
+    const list = await searchRules(q, { kind: 'solution', limit: 20 });
+    spinner.stop();
+    if (list.length === 0) {
+        console.log(chalk.yellow('No solutions found.'));
+        return;
+    }
+    const choice = await inquirer.prompt([
+        {
+            name: 'id',
+            message: 'Select a solution',
+            type: 'list',
+            choices: list.map((r) => ({ name: `${r.title} (${r.id})`, value: r.id })),
+        },
+    ]);
+    const rule = await getRuleById(choice.id);
+    if (rule) {
+        console.log(chalk.cyan(rule.title));
+        console.log(rule.body);
+    }
+};
+export const runSolutionsPull = async (id) => {
+    if (!loadCredentials()) {
+        console.error(chalk.red('Not logged in. Run bitcompass login.'));
+        process.exit(1);
+    }
+    let targetId = id;
+    if (!targetId) {
+        const spinner = ora('Loading solutions…').start();
+        const list = await fetchRules('solution');
+        spinner.stop();
+        if (list.length === 0) {
+            console.log(chalk.yellow('No solutions to pull.'));
+            return;
+        }
+        const choice = await inquirer.prompt([
+            { name: 'id', message: 'Select solution', type: 'list', choices: list.map((r) => ({ name: r.title, value: r.id })) },
+        ]);
+        targetId = choice.id;
+    }
+    const rule = await getRuleById(targetId);
+    if (!rule) {
+        console.error(chalk.red('Solution not found.'));
+        process.exit(1);
+    }
+    const filename = `solution-${rule.id}.md`;
+    const content = `# ${rule.title}\n\n${rule.description}\n\n## Solution\n\n${rule.body}\n`;
+    writeFileSync(filename, content);
+    console.log(chalk.green('Wrote'), filename);
+};
+export const runSolutionsPush = async (file) => {
+    if (!loadCredentials()) {
+        console.error(chalk.red('Not logged in. Run bitcompass login.'));
+        process.exit(1);
+    }
+    let payload;
+    if (file) {
+        const { readFileSync } = await import('fs');
+        const raw = readFileSync(file, 'utf-8');
+        try {
+            payload = JSON.parse(raw);
+            payload.kind = 'solution';
+        }
+        catch {
+            const lines = raw.split('\n');
+            const title = lines[0].replace(/^#\s*/, '') || 'Untitled';
+            payload = { kind: 'solution', title, description: '', body: raw };
+        }
+    }
+    else {
+        const answers = await inquirer.prompt([
+            { name: 'title', message: 'Problem title', type: 'input', default: 'Untitled' },
+            { name: 'description', message: 'Description', type: 'input', default: '' },
+            { name: 'body', message: 'Solution content', type: 'editor', default: '' },
+        ]);
+        payload = { kind: 'solution', title: answers.title, description: answers.description, body: answers.body };
+    }
+    const spinner = ora('Publishing solution…').start();
+    const created = await insertRule(payload);
+    spinner.succeed(chalk.green('Published solution ') + created.id);
+    console.log(chalk.dim(created.title));
+};

package/dist/commands/whoami.d.ts

@@ -0,0 +1 @@
+export declare const runWhoami: () => void;

package/dist/commands/whoami.js

@@ -0,0 +1,16 @@
+import { loadCredentials } from '../auth/config.js';
+import chalk from 'chalk';
+export const runWhoami = () => {
+    const creds = loadCredentials();
+    if (!creds?.access_token) {
+        console.error(chalk.red('Not logged in. Run bitcompass login.'));
+        process.exit(1);
+    }
+    const email = creds.user?.email;
+    if (email) {
+        console.log(email);
+    }
+    else {
+        console.log(chalk.yellow('Logged in (email not stored). Run bitcompass login to refresh.'));
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import 'dotenv/config';

package/dist/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { runConfigGet, runConfigList, runConfigSet } from './commands/config-cmd.js';
+import { runLogin } from './commands/login.js';
+import { runLogout } from './commands/logout.js';
+import { runMcpStart, runMcpStatus } from './commands/mcp.js';
+import { runRulesList, runRulesPull, runRulesPush, runRulesSearch } from './commands/rules.js';
+import { runSolutionsPull, runSolutionsPush, runSolutionsSearch } from './commands/solutions.js';
+import { runWhoami } from './commands/whoami.js';
+const program = new Command();
+program
+    .name('bitcompass')
+    .description('BitCompass CLI - rules, solutions, and MCP server')
+    .version('0.1.0');
+program
+    .command('login')
+    .description('Log in with Google (opens browser)')
+    .action(() => runLogin().catch((err) => { console.error(chalk.red(err.message)); process.exit(1); }));
+program
+    .command('logout')
+    .description('Remove stored credentials')
+    .action(runLogout);
+program
+    .command('whoami')
+    .description('Show current user (email)')
+    .action(runWhoami);
+const configCmd = program.command('config').description('Show or set config');
+configCmd.action(runConfigList);
+configCmd.command('list').description('List config values').action(runConfigList);
+configCmd.command('set <key> <value>').description('Set supabaseUrl, supabaseAnonKey, or apiUrl').action((key, value) => runConfigSet(key, value));
+configCmd.command('get <key>').description('Get a config value').action((key) => runConfigGet(key));
+// rules
+const rules = program.command('rules').description('Manage rules');
+rules.command('search [query]').description('Search rules').action((query) => runRulesSearch(query).catch(handleErr));
+rules.command('list').description('List rules').action(() => runRulesList().catch(handleErr));
+rules.command('pull [id]').description('Pull a rule by ID or choose from list').action((id) => runRulesPull(id).catch(handleErr));
+rules.command('push [file]').description('Push a rule (file or interactive)').action((file) => runRulesPush(file).catch(handleErr));
+// solutions
+const solutions = program.command('solutions').description('Manage solutions');
+solutions.command('search [query]').description('Search solutions').action((query) => runSolutionsSearch(query).catch(handleErr));
+solutions.command('pull [id]').description('Pull a solution by ID or choose from list').action((id) => runSolutionsPull(id).catch(handleErr));
+solutions.command('push [file]').description('Push a solution (file or interactive)').action((file) => runSolutionsPush(file).catch(handleErr));
+// mcp
+const mcp = program.command('mcp').description('MCP server');
+mcp.command('start').description('Start MCP server (stdio)').action(() => runMcpStart().catch(handleErr));
+mcp.command('status').description('Show MCP status').action(runMcpStatus);
+function handleErr(err) {
+    console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+}
+program.parse();

package/dist/mcp/server.d.ts

@@ -0,0 +1 @@
+export declare const startMcpServer: () => Promise<void>;

package/dist/mcp/server.js

@@ -0,0 +1,225 @@
+import { insertRule, searchRules } from '../api/client.js';
+import { loadCredentials } from '../auth/config.js';
+function createStdioServer() {
+    const handlers = new Map();
+    let requestId = 0;
+    const send = (msg) => {
+        process.stdout.write(JSON.stringify(msg) + '\n');
+    };
+    const handleRequest = async (msg) => {
+        const isNotification = msg.id === undefined || msg.id === null;
+        const id = isNotification ? undefined : msg.id;
+        try {
+            if (msg.method === 'notified' && msg.params?.method === 'notifications/initialized') {
+                return;
+            }
+            if (isNotification)
+                return;
+            if (msg.method === 'initialize') {
+                send({
+                    jsonrpc: '2.0',
+                    id,
+                    result: {
+                        protocolVersion: '2024-11-05',
+                        capabilities: { tools: {}, prompts: {} },
+                        serverInfo: { name: 'bitcompass', version: '0.1.0' },
+                    },
+                });
+                return;
+            }
+            if (msg.method === 'tools/list') {
+                send({
+                    jsonrpc: '2.0',
+                    id,
+                    result: {
+                        tools: [
+                            {
+                                name: 'search-rules',
+                                description: 'Search BitCompass rules by query',
+                                inputSchema: {
+                                    type: 'object',
+                                    properties: { query: { type: 'string' }, kind: { type: 'string', enum: ['rule', 'solution'] }, limit: { type: 'number' } },
+                                    required: ['query'],
+                                },
+                            },
+                            {
+                                name: 'search-solutions',
+                                description: 'Search BitCompass solutions by query',
+                                inputSchema: {
+                                    type: 'object',
+                                    properties: { query: { type: 'string' }, limit: { type: 'number' } },
+                                    required: ['query'],
+                                },
+                            },
+                            {
+                                name: 'post-rules',
+                                description: 'Publish a new rule or solution to BitCompass',
+                                inputSchema: {
+                                    type: 'object',
+                                    properties: {
+                                        kind: { type: 'string', enum: ['rule', 'solution'] },
+                                        title: { type: 'string' },
+                                        description: { type: 'string' },
+                                        body: { type: 'string' },
+                                        context: { type: 'string' },
+                                        examples: { type: 'array', items: { type: 'string' } },
+                                        technologies: { type: 'array', items: { type: 'string' } },
+                                    },
+                                    required: ['kind', 'title', 'body'],
+                                },
+                            },
+                        ],
+                    },
+                });
+                return;
+            }
+            if (msg.method === 'tools/call') {
+                const params = msg.params;
+                const name = params?.name;
+                const args = params?.arguments ?? {};
+                const handler = name ? handlers.get(name) : undefined;
+                if (!handler) {
+                    send({ jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown tool: ${name}` } });
+                    return;
+                }
+                const result = await handler(args);
+                send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify(result) }] } });
+                return;
+            }
+            if (msg.method === 'prompts/list') {
+                send({
+                    jsonrpc: '2.0',
+                    id,
+                    result: {
+                        prompts: [
+                            { name: 'share_new_rule', title: 'Share a new rule', description: 'Guide to collect and publish a reusable rule' },
+                            { name: 'share_problem_solution', title: 'Share a problem solution', description: 'Guide to collect and publish a problem solution' },
+                        ],
+                    },
+                });
+                return;
+            }
+            if (msg.method === 'prompts/get') {
+                const params = msg.params;
+                const name = params?.name ?? '';
+                if (name === 'share_new_rule') {
+                    send({
+                        jsonrpc: '2.0',
+                        id,
+                        result: {
+                            messages: [
+                                { role: 'user', content: { type: 'text', text: 'You are helping formalize a reusable rule. Collect: title, description, rule body, and optionally technologies/tags. Ask one question at a time. Then call post-rules with kind: "rule".' } },
+                            ],
+                        },
+                    });
+                    return;
+                }
+                if (name === 'share_problem_solution') {
+                    send({
+                        jsonrpc: '2.0',
+                        id,
+                        result: {
+                            messages: [
+                                { role: 'user', content: { type: 'text', text: 'You are helping share a problem solution. Collect: problem title, description, and solution text. Ask one question at a time. Then call post-rules with kind: "solution".' } },
+                            ],
+                        },
+                    });
+                    return;
+                }
+                send({ jsonrpc: '2.0', id, error: { code: -32602, message: 'Unknown prompt' } });
+                return;
+            }
+            send({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } });
+        }
+        catch (err) {
+            if (id !== undefined) {
+                send({
+                    jsonrpc: '2.0',
+                    id,
+                    error: { code: -32603, message: err instanceof Error ? err.message : String(err) },
+                });
+            }
+        }
+    };
+    let buffer = '';
+    const queue = [];
+    let processing = false;
+    const processQueue = async () => {
+        if (processing || queue.length === 0)
+            return;
+        processing = true;
+        while (queue.length > 0) {
+            const msg = queue.shift();
+            await handleRequest(msg);
+        }
+        processing = false;
+    };
+    const onData = (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const msg = JSON.parse(line);
+                queue.push(msg);
+                void processQueue();
+            }
+            catch {
+                // ignore malformed
+            }
+        }
+    };
+    process.stdin.on('data', onData);
+    // Register tool implementations
+    handlers.set('search-rules', async (args) => {
+        const creds = loadCredentials();
+        if (!creds?.access_token)
+            return { error: 'Run bitcompass login first.' };
+        const query = args.query ?? '';
+        const kind = args.kind;
+        const limit = args.limit ?? 20;
+        const list = await searchRules(query, { kind, limit });
+        return { rules: list.map((r) => ({ id: r.id, title: r.title, kind: r.kind, snippet: r.body.slice(0, 200) })) };
+    });
+    handlers.set('search-solutions', async (args) => {
+        const creds = loadCredentials();
+        if (!creds?.access_token)
+            return { error: 'Run bitcompass login first.' };
+        const query = args.query ?? '';
+        const limit = args.limit ?? 20;
+        const list = await searchRules(query, { kind: 'solution', limit });
+        return { solutions: list.map((r) => ({ id: r.id, title: r.title, snippet: r.body.slice(0, 200) })) };
+    });
+    handlers.set('post-rules', async (args) => {
+        const creds = loadCredentials();
+        if (!creds?.access_token)
+            return { error: 'Run bitcompass login first.' };
+        const payload = {
+            kind: args.kind ?? 'rule',
+            title: args.title ?? 'Untitled',
+            description: args.description ?? '',
+            body: args.body ?? '',
+            context: args.context || undefined,
+            examples: Array.isArray(args.examples) ? args.examples : undefined,
+            technologies: Array.isArray(args.technologies) ? args.technologies : undefined,
+        };
+        const created = await insertRule(payload);
+        return { id: created.id, title: created.title, success: true };
+    });
+    return {
+        async connect() {
+            // Stdio listener already attached; keep process alive
+        },
+    };
+}
+export const startMcpServer = async () => {
+    const creds = loadCredentials();
+    if (!creds?.access_token) {
+        process.stderr.write('Not logged in. Run bitcompass login first.\n');
+        process.exit(1);
+    }
+    const server = createStdioServer();
+    await server.connect();
+};

package/dist/types.d.ts

@@ -0,0 +1,36 @@
+export type RuleKind = 'rule' | 'solution';
+export interface Rule {
+    id: string;
+    kind: RuleKind;
+    title: string;
+    description: string;
+    body: string;
+    context?: string | null;
+    examples?: string[];
+    technologies?: string[];
+    user_id: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface RuleInsert {
+    kind: RuleKind;
+    title: string;
+    description: string;
+    body: string;
+    context?: string | null;
+    examples?: string[];
+    technologies?: string[];
+}
+export interface StoredCredentials {
+    access_token: string;
+    refresh_token: string;
+    expires_at?: number;
+    user?: {
+        email?: string;
+    };
+}
+export interface BitcompassConfig {
+    apiUrl?: string;
+    supabaseUrl?: string;
+    supabaseAnonKey?: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "bitcompass",
+  "version": "0.1.0",
+  "description": "BitCompass CLI - rules, solutions, and MCP server",
+  "type": "module",
+  "bin": { "bitcompass": "./dist/index.js" },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepare": "npm run build"
+  },
+  "engines": { "node": ">=18" },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/company-compass/company-compass.git",
+    "directory": "packages/bitcompass-cli"
+  },
+  "license": "MIT",
+  "keywords": ["mcp", "cursor", "rules", "bitcompass", "cli", "supabase"],
+  "dependencies": {
+    "dotenv": "^16.4.5",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@supabase/supabase-js": "^2.45.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "inquirer": "^9.2.22",
+    "ky": "^1.7.2",
+    "open": "^10.1.0",
+    "ora": "^8.1.1",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0"
+  },
+  "files": ["dist"]
+}