bitcompass 0.2.9 → 0.3.1

package/README.md

@@ -72,7 +72,26 @@ 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**.
 
-Tools: `search-rules`, `search-solutions`, `post-rules`. Prompts: `share_new_rule`, `share_problem_solution`.
+### MCP Tools
+
+**Rules & Solutions:**
+- `search-rules` - Search rules by query (with optional kind filter)
+- `search-solutions` - Search solutions by query
+- `get-rule` - Get full rule/solution details by ID
+- `list-rules` - List all rules/solutions (with optional kind filter and limit)
+- `post-rules` - Create/publish a new rule or solution
+- `update-rule` - Update an existing rule or solution
+- `delete-rule` - Delete a rule or solution by ID
+- `pull-rule` - Pull a rule/solution to a file in the project rules directory
+
+**Activity Logs:**
+- `create-activity-log` - Create activity log from git repo (day/week/month)
+- `list-activity-logs` - List user's activity logs (with optional filters)
+- `get-activity-log` - Get activity log details by ID
+
+**Prompts:**
+- `share_new_rule` - Guide to collect and publish a reusable rule
+- `share_problem_solution` - Guide to collect and publish a problem solution
 
 ## Publish (maintainers)
 

package/dist/api/client.d.ts

@@ -1,5 +1,5 @@
 import { type SupabaseClient } from '@supabase/supabase-js';
-import type { ActivityLog, ActivityLogInsert, Rule, RuleInsert } from '../types.js';
+import type { ActivityLog, ActivityLogInsert, Rule, RuleInsert, RuleKind } from '../types.js';
 /** Shown when MCP is used before logging in; instructs user to login and restart MCP. */
 export declare const AUTH_REQUIRED_MSG = "BitCompass needs authentication. Run `bitcompass login`, then restart the MCP server in your editor.";
 /** Shown when Supabase URL/key are not set; instructs config then login then restart MCP. */
@@ -8,9 +8,9 @@ export declare const NOT_CONFIGURED_MSG = "BitCompass is not configured. Run `bi
 export declare const getSupabaseClient: () => SupabaseClient | null;
 /** Client for public read-only (rules/solutions). Works without login when RLS allows public select. */
 export declare const getSupabaseClientForRead: () => SupabaseClient | null;
-export declare const fetchRules: (kind?: "rule" | "solution") => Promise<Rule[]>;
+export declare const fetchRules: (kind?: RuleKind) => Promise<Rule[]>;
 export declare const searchRules: (queryText: string, options?: {
-    kind?: "rule" | "solution";
+    kind?: RuleKind;
     limit?: number;
 }) => Promise<Rule[]>;
 export declare const getRuleById: (id: string) => Promise<Rule | null>;
@@ -18,3 +18,8 @@ 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>;
 export declare const insertActivityLog: (payload: ActivityLogInsert) => Promise<ActivityLog>;
+export declare const fetchActivityLogs: (options?: {
+    limit?: number;
+    time_frame?: "day" | "week" | "month";
+}) => Promise<ActivityLog[]>;
+export declare const getActivityLogById: (id: string) => Promise<ActivityLog | null>;

package/dist/api/client.js

@@ -135,3 +135,31 @@ export const insertActivityLog = async (payload) => {
         throw new Error(isAuthError(error) ? AUTH_REQUIRED_MSG : error.message);
     return data;
 };
+export const fetchActivityLogs = async (options) => {
+    const client = getSupabaseClient();
+    if (!client)
+        throw new Error(NOT_CONFIGURED_MSG);
+    let query = client.from('activity_logs').select('*').order('created_at', { ascending: false });
+    if (options?.time_frame) {
+        query = query.eq('time_frame', options.time_frame);
+    }
+    if (options?.limit) {
+        query = query.limit(options.limit);
+    }
+    const { data, error } = await query;
+    if (error)
+        throw new Error(isAuthError(error) ? AUTH_REQUIRED_MSG : error.message);
+    return (data ?? []);
+};
+export const getActivityLogById = async (id) => {
+    const client = getSupabaseClient();
+    if (!client)
+        throw new Error(NOT_CONFIGURED_MSG);
+    const { data, error } = await client.from('activity_logs').select('*').eq('id', id).single();
+    if (error) {
+        if (error.code === 'PGRST116')
+            return null;
+        throw new Error(isAuthError(error) ? AUTH_REQUIRED_MSG : error.message);
+    }
+    return data;
+};

package/dist/commands/init.js

@@ -1,8 +1,8 @@
-import inquirer from 'inquirer';
 import chalk from 'chalk';
-import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import inquirer from 'inquirer';
 import { join } from 'path';
-import { getEditorDefaultPath, loadProjectConfig, saveProjectConfig, getProjectConfigDir, } from '../auth/project-config.js';
+import { getEditorDefaultPath, getProjectConfigDir, loadProjectConfig, saveProjectConfig, } from '../auth/project-config.js';
 const EDITOR_CHOICES = [
     { name: 'VSCode', value: 'vscode' },
     { name: 'Cursor', value: 'cursor' },
@@ -48,9 +48,158 @@ export const runInit = async () => {
     };
     saveProjectConfig(config);
     ensureGitignoreEntry();
+    // Create rule file about BitCompass MCP and CLI usage
+    const outputDir = join(process.cwd(), config.outputPath);
+    mkdirSync(outputDir, { recursive: true });
+    const rulePath = join(outputDir, 'rule-bitcompass-mcp-and-cli-usage.md');
+    const ruleContent = `# BitCompass MCP and CLI Usage
+
+This project uses BitCompass for managing rules, solutions, and activity logs. LLMs should use the available MCP tools and CLI commands when appropriate.
+
+## MCP Tools (Available in AI Editor)
+
+Use these tools directly from the AI editor when available:
+
+### search-rules
+Search BitCompass rules by query.
+
+**When to use:** When you need to find existing rules or patterns that might help solve a problem.
+
+**Parameters:**
+- \`query\` (required): Search query string
+- \`kind\` (optional): Filter by 'rule' or 'solution'
+- \`limit\` (optional): Maximum number of results (default: 20)
+
+**Example:** Search for rules about "authentication" or "error handling"
+
+### search-solutions
+Search BitCompass solutions by query.
+
+**When to use:** When you need to find solutions to specific problems.
+
+**Parameters:**
+- \`query\` (required): Search query string
+- \`limit\` (optional): Maximum number of results (default: 20)
+
+**Example:** Search for solutions about "database connection issues"
+
+### post-rules
+Publish a new rule or solution to BitCompass.
+
+**When to use:** When you've created a reusable pattern, best practice, or solution that should be shared with the team.
+
+**Parameters:**
+- \`kind\` (required): 'rule' or 'solution'
+- \`title\` (required): Title of the rule/solution
+- \`body\` (required): Full content of the rule/solution
+- \`description\` (optional): Short description
+- \`context\` (optional): Additional context
+- \`examples\` (optional): Array of example strings
+- \`technologies\` (optional): Array of technology tags
+
+**Example:** After implementing a new pattern, publish it as a rule so others can reuse it.
+
+### create-activity-log
+Collect repository summary and git activity, then push to activity logs.
+
+**When to use:** When the user asks to log their work or track activity for a specific time period.
+
+**Parameters:**
+- \`time_frame\` (required): 'day', 'week', or 'month'
+- \`repo_path\` (optional): Path to git repo (defaults to current directory)
+
+**Example:** User asks "log my work for this week" → call with time_frame: 'week'
+
+## CLI Commands (Run via Terminal)
+
+Use these commands when you need to interact with BitCompass from the terminal:
+
+### Authentication
+- \`bitcompass login\` - Log in with Google (opens browser)
+- \`bitcompass logout\` - Remove stored credentials
+- \`bitcompass whoami\` - Show current user (email)
+
+**When to use:** When authentication is required or to verify login status.
+
+### Project Configuration
+- \`bitcompass init\` - Configure project: editor/AI provider and output folder
+
+**When to use:** Run once per project to set up BitCompass configuration.
+
+### Rules Management
+- \`bitcompass rules search [query]\` - Search rules interactively
+- \`bitcompass rules list\` - List all available rules
+- \`bitcompass rules pull [id]\` - Pull a rule by ID (saves to project rules folder)
+  - Use \`--global\` flag to install globally to ~/.cursor/rules/
+- \`bitcompass rules push [file]\` - Push a rule file to BitCompass
+
+**When to use:** 
+- \`pull\`: When you want to download and use a specific rule in your project
+- \`push\`: When you've created a rule file and want to share it
+- \`search\`/\`list\`: When browsing available rules
+
+### Solutions Management
+- \`bitcompass solutions search [query]\` - Search solutions interactively
+- \`bitcompass solutions pull [id]\` - Pull a solution by ID
+  - Use \`--global\` flag to install globally
+- \`bitcompass solutions push [file]\` - Push a solution file to BitCompass
+
+**When to use:** Similar to rules, but for problem-solution pairs.
+
+### Activity Logs
+- \`bitcompass log\` - Collect repo summary and git activity, push to activity logs
+- \`bitcompass log YYYY-MM-DD\` - Log activity for a specific date
+- \`bitcompass log YYYY-MM-DD YYYY-MM-DD\` - Log activity for a date range
+
+**When to use:** When the user wants to track or log their development activity.
+
+### Configuration
+- \`bitcompass config list\` - List all config values
+- \`bitcompass config get <key>\` - Get a specific config value
+- \`bitcompass config set <key> <value>\` - Set config value (supabaseUrl, supabaseAnonKey, apiUrl)
+
+**When to use:** When you need to check or modify BitCompass configuration.
+
+### MCP Server
+- \`bitcompass mcp start\` - Start MCP server (stdio mode for AI editors)
+- \`bitcompass mcp status\` - Show MCP server status
+
+**When to use:** Usually configured automatically by the AI editor. Use \`status\` to verify MCP is working.
+
+## Decision Guide
+
+**Use MCP tools when:**
+- You're working in the AI editor and need to search or publish rules/solutions
+- The user asks you to search for existing patterns or solutions
+- You've created something reusable and want to share it immediately
+- The user wants to log their activity
+
+**Use CLI commands when:**
+- You need to authenticate or verify authentication
+- The user explicitly asks to run a CLI command
+- You need to pull rules/solutions to the project (for version control)
+- You need to check or modify configuration
+- The MCP tool is not available or returns an authentication error
+
+## Authentication Notes
+
+- Most MCP tools require authentication (except search-rules and search-solutions)
+- If you get an authentication error, instruct the user to run \`bitcompass login\` and restart the MCP server
+- CLI commands that require auth will prompt the user to login
+
+## Best Practices
+
+1. **Search before creating:** Before publishing a new rule, search to see if something similar exists
+2. **Use descriptive titles:** When posting rules/solutions, use clear, searchable titles
+3. **Include context:** Add context, examples, and technologies when posting to make rules more discoverable
+4. **Pull for version control:** Use \`rules pull\` or \`solutions pull\` to add rules to your project's rules folder (tracked in git)
+5. **Global vs project:** Use \`--global\` flag when you want a rule available across all projects, otherwise use project-specific rules
+`;
+    writeFileSync(rulePath, ruleContent, 'utf-8');
     console.log(chalk.green('Project configured.'));
     console.log(chalk.dim('Config:'), join(getProjectConfigDir(), 'config.json'));
     console.log(chalk.dim('Editor:'), config.editor);
     console.log(chalk.dim('Output path:'), config.outputPath);
     console.log(chalk.dim('.gitignore:'), GITIGNORE_ENTRY, 'added or already present.');
+    console.log(chalk.green('Rule created:'), rulePath);
 };

package/dist/lib/rule-file-ops.d.ts

@@ -0,0 +1,11 @@
+export interface PullRuleOptions {
+    /** Install globally to ~/.cursor/rules/ for all projects */
+    global?: boolean;
+    /** Custom output path (overrides project config and global) */
+    outputPath?: string;
+}
+/**
+ * Pulls a rule or solution to a file. Returns the file path where it was written.
+ * Throws if rule not found or if authentication is required.
+ */
+export declare const pullRuleToFile: (id: string, options?: PullRuleOptions) => Promise<string>;

package/dist/lib/rule-file-ops.js

@@ -0,0 +1,39 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getRuleById } from '../api/client.js';
+import { getProjectConfig } from '../auth/project-config.js';
+import { ruleFilename, solutionFilename } from './slug.js';
+/**
+ * Pulls a rule or solution to a file. Returns the file path where it was written.
+ * Throws if rule not found or if authentication is required.
+ */
+export const pullRuleToFile = async (id, options = {}) => {
+    const rule = await getRuleById(id);
+    if (!rule) {
+        throw new Error(`Rule or solution with ID ${id} not found.`);
+    }
+    let outDir;
+    if (options.outputPath) {
+        // Custom output path takes precedence
+        outDir = options.outputPath.startsWith('/') ? options.outputPath : join(process.cwd(), options.outputPath);
+    }
+    else if (options.global) {
+        // Use global location: ~/.cursor/rules/
+        outDir = join(homedir(), '.cursor', 'rules');
+    }
+    else {
+        // Use project config (default behavior)
+        const { outputPath } = getProjectConfig({ warnIfMissing: true });
+        outDir = join(process.cwd(), outputPath);
+    }
+    mkdirSync(outDir, { recursive: true });
+    const filename = rule.kind === 'solution'
+        ? join(outDir, solutionFilename(rule.title, rule.id))
+        : join(outDir, ruleFilename(rule.title, rule.id));
+    const content = rule.kind === 'solution'
+        ? `# ${rule.title}\n\n${rule.description}\n\n## Solution\n\n${rule.body}\n`
+        : `# ${rule.title}\n\n${rule.description}\n\n${rule.body}\n`;
+    writeFileSync(filename, content);
+    return filename;
+};

package/dist/mcp/server.js

@@ -1,7 +1,8 @@
-import { AUTH_REQUIRED_MSG, insertRule, searchRules } from '../api/client.js';
+import { AUTH_REQUIRED_MSG, insertRule, searchRules, getRuleById, fetchRules, updateRule, deleteRule, fetchActivityLogs, getActivityLogById, } from '../api/client.js';
 import { buildAndPushActivityLog } from '../commands/log.js';
 import { loadCredentials } from '../auth/config.js';
 import { getProjectConfig } from '../auth/project-config.js';
+import { pullRuleToFile } from '../lib/rule-file-ops.js';
 /** When token is missing, we fail initialize so Cursor shows "Needs authentication" (yellow) instead of success (green). */
 const NEEDS_AUTH_ERROR_MESSAGE = 'Needs authentication';
 const NEEDS_AUTH_ERROR_CODE = -32001; // Server error: auth required
@@ -59,7 +60,7 @@ function createStdioServer() {
                                 description: 'Search BitCompass rules by query',
                                 inputSchema: {
                                     type: 'object',
-                                    properties: { query: { type: 'string' }, kind: { type: 'string', enum: ['rule', 'solution'] }, limit: { type: 'number' } },
+                                    properties: { query: { type: 'string' }, kind: { type: 'string', enum: ['rule', 'solution', 'skill', 'command'] }, limit: { type: 'number' } },
                                     required: ['query'],
                                 },
                             },
@@ -78,7 +79,7 @@ function createStdioServer() {
                                 inputSchema: {
                                     type: 'object',
                                     properties: {
-                                        kind: { type: 'string', enum: ['rule', 'solution'] },
+                                        kind: { type: 'string', enum: ['rule', 'solution', 'skill', 'command'] },
                                         title: { type: 'string' },
                                         description: { type: 'string' },
                                         body: { type: 'string' },
@@ -101,6 +102,92 @@ function createStdioServer() {
                                     required: ['time_frame'],
                                 },
                             },
+                            {
+                                name: 'get-rule',
+                                description: 'Get full details of a rule or solution by ID',
+                                inputSchema: {
+                                    type: 'object',
+                                    properties: {
+                                        id: { type: 'string', description: 'Rule/solution ID' },
+                                        kind: { type: 'string', enum: ['rule', 'solution'], description: 'Optional: filter by kind' },
+                                    },
+                                    required: ['id'],
+                                },
+                            },
+                            {
+                                name: 'list-rules',
+                                description: 'List all rules and solutions (with optional filtering by kind)',
+                                inputSchema: {
+                                    type: 'object',
+                                    properties: {
+                                        kind: { type: 'string', enum: ['rule', 'solution'], description: 'Optional: filter by kind' },
+                                        limit: { type: 'number', description: 'Optional: maximum number of results (default: 50)' },
+                                    },
+                                },
+                            },
+                            {
+                                name: 'update-rule',
+                                description: 'Update an existing rule or solution',
+                                inputSchema: {
+                                    type: 'object',
+                                    properties: {
+                                        id: { type: 'string', description: 'Rule/solution ID to update' },
+                                        title: { type: 'string', description: 'Updated title' },
+                                        description: { type: 'string', description: 'Updated description' },
+                                        body: { type: 'string', description: 'Updated body content' },
+                                        context: { type: 'string', description: 'Updated context' },
+                                        examples: { type: 'array', items: { type: 'string' }, description: 'Updated examples array' },
+                                        technologies: { type: 'array', items: { type: 'string' }, description: 'Updated technologies array' },
+                                    },
+                                    required: ['id'],
+                                },
+                            },
+                            {
+                                name: 'delete-rule',
+                                description: 'Delete a rule or solution by ID',
+                                inputSchema: {
+                                    type: 'object',
+                                    properties: {
+                                        id: { type: 'string', description: 'Rule/solution ID to delete' },
+                                    },
+                                    required: ['id'],
+                                },
+                            },
+                            {
+                                name: 'pull-rule',
+                                description: 'Pull a rule or solution to a file in the project rules directory',
+                                inputSchema: {
+                                    type: 'object',
+                                    properties: {
+                                        id: { type: 'string', description: 'Rule/solution ID to pull' },
+                                        output_path: { type: 'string', description: 'Optional: custom output path' },
+                                        global: { type: 'boolean', description: 'Install globally to ~/.cursor/rules/' },
+                                    },
+                                    required: ['id'],
+                                },
+                            },
+                            {
+                                name: 'list-activity-logs',
+                                description: "List user's activity logs",
+                                inputSchema: {
+                                    type: 'object',
+                                    properties: {
+                                        limit: { type: 'number', description: 'Optional: maximum number of results (default: 20)' },
+                                        time_frame: { type: 'string', enum: ['day', 'week', 'month'], description: 'Optional: filter by time frame' },
+                                    },
+                                },
+                            },
+                            {
+                                name: 'get-activity-log',
+                                description: 'Get activity log details by ID',
+                                inputSchema: {
+                                    type: 'object',
+                                    properties: {
+                                        id: { type: 'string', description: 'Activity log ID' },
+                                    },
+                                    required: ['id'],
+                                },
+                            },
                         ],
                     },
                 });
@@ -270,6 +357,177 @@ function createStdioServer() {
             return { error: msg };
         }
     });
+    handlers.set('get-rule', async (args) => {
+        const id = args.id;
+        if (!id)
+            return { error: 'id is required' };
+        const kind = args.kind;
+        try {
+            const rule = await getRuleById(id);
+            if (!rule) {
+                return { error: `Rule or solution with ID ${id} not found.` };
+            }
+            if (kind && rule.kind !== kind) {
+                return { error: `Rule with ID ${id} is a ${rule.kind}, not a ${kind}.` };
+            }
+            return {
+                id: rule.id,
+                kind: rule.kind,
+                title: rule.title,
+                description: rule.description,
+                body: rule.body,
+                context: rule.context ?? null,
+                examples: rule.examples ?? [],
+                technologies: rule.technologies ?? [],
+                author: rule.author_display_name ?? null,
+                created_at: rule.created_at,
+                updated_at: rule.updated_at,
+            };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : 'Failed to get rule.';
+            return { error: msg };
+        }
+    });
+    handlers.set('list-rules', async (args) => {
+        const kind = args.kind;
+        const limit = args.limit ?? 50;
+        try {
+            const list = await fetchRules(kind);
+            const limited = list.slice(0, limit);
+            return {
+                rules: limited.map((r) => ({
+                    id: r.id,
+                    title: r.title,
+                    kind: r.kind,
+                    description: r.description,
+                    author: r.author_display_name ?? null,
+                    snippet: r.body.slice(0, 200),
+                    created_at: r.created_at,
+                })),
+                total: list.length,
+                returned: limited.length,
+            };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : 'Failed to list rules.';
+            return { error: msg };
+        }
+    });
+    handlers.set('update-rule', async (args) => {
+        if (!loadCredentials()?.access_token)
+            return { error: AUTH_REQUIRED_MSG };
+        const id = args.id;
+        if (!id)
+            return { error: 'id is required' };
+        const updates = {};
+        if (args.title !== undefined)
+            updates.title = args.title;
+        if (args.description !== undefined)
+            updates.description = args.description;
+        if (args.body !== undefined)
+            updates.body = args.body;
+        if (args.context !== undefined)
+            updates.context = args.context || undefined;
+        if (Array.isArray(args.examples))
+            updates.examples = args.examples;
+        if (Array.isArray(args.technologies))
+            updates.technologies = args.technologies;
+        try {
+            const updated = await updateRule(id, updates);
+            return {
+                id: updated.id,
+                title: updated.title,
+                kind: updated.kind,
+                success: true,
+            };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : 'Failed to update rule.';
+            return { error: msg };
+        }
+    });
+    handlers.set('delete-rule', async (args) => {
+        if (!loadCredentials()?.access_token)
+            return { error: AUTH_REQUIRED_MSG };
+        const id = args.id;
+        if (!id)
+            return { error: 'id is required' };
+        try {
+            await deleteRule(id);
+            return { success: true, id };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : 'Failed to delete rule.';
+            return { error: msg };
+        }
+    });
+    handlers.set('pull-rule', async (args) => {
+        if (!loadCredentials()?.access_token)
+            return { error: AUTH_REQUIRED_MSG };
+        const id = args.id;
+        if (!id)
+            return { error: 'id is required' };
+        const global = Boolean(args.global);
+        const outputPath = typeof args.output_path === 'string' ? args.output_path : undefined;
+        try {
+            const filePath = await pullRuleToFile(id, { global, outputPath });
+            return { success: true, file_path: filePath, id };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : 'Failed to pull rule.';
+            return { error: msg };
+        }
+    });
+    handlers.set('list-activity-logs', async (args) => {
+        if (!loadCredentials()?.access_token)
+            return { error: AUTH_REQUIRED_MSG };
+        const limit = args.limit ?? 20;
+        const timeFrame = args.time_frame;
+        try {
+            const logs = await fetchActivityLogs({ limit, time_frame: timeFrame });
+            return {
+                logs: logs.map((log) => ({
+                    id: log.id,
+                    time_frame: log.time_frame,
+                    period_start: log.period_start,
+                    period_end: log.period_end,
+                    created_at: log.created_at,
+                })),
+                total: logs.length,
+            };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : 'Failed to list activity logs.';
+            return { error: msg };
+        }
+    });
+    handlers.set('get-activity-log', async (args) => {
+        if (!loadCredentials()?.access_token)
+            return { error: AUTH_REQUIRED_MSG };
+        const id = args.id;
+        if (!id)
+            return { error: 'id is required' };
+        try {
+            const log = await getActivityLogById(id);
+            if (!log) {
+                return { error: `Activity log with ID ${id} not found.` };
+            }
+            return {
+                id: log.id,
+                time_frame: log.time_frame,
+                period_start: log.period_start,
+                period_end: log.period_end,
+                repo_summary: log.repo_summary,
+                git_analysis: log.git_analysis,
+                created_at: log.created_at,
+            };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : 'Failed to get activity log.';
+            return { error: msg };
+        }
+    });
     return {
         async connect() {
             // Stdio listener already attached; keep process alive

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export type RuleKind = 'rule' | 'solution';
+export type RuleKind = 'rule' | 'solution' | 'skill' | 'command';
 export interface Rule {
     id: string;
     kind: RuleKind;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bitcompass",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "description": "BitCompass CLI - rules, solutions, and MCP server",
   "type": "module",
   "bin": {
@@ -10,6 +10,7 @@
     "build": "tsc",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
+    "publish": "npm publish --access public",
     "prepare": "npm run build",
     "postinstall": "node scripts/postinstall.js"
   },