bitcompass 0.2.5 → 0.2.7

package/dist/auth/project-config.d.ts

@@ -0,0 +1,16 @@
+import type { EditorProvider, ProjectConfig } from '../types.js';
+declare const EDITOR_DEFAULT_PATHS: Record<EditorProvider, string>;
+declare const DEFAULT_EDITOR: EditorProvider;
+declare const DEFAULT_OUTPUT_PATH: string;
+export declare const getProjectConfigDir: () => string;
+export declare const getEditorDefaultPath: (editor: EditorProvider) => string;
+export declare const loadProjectConfig: () => ProjectConfig | null;
+export declare const saveProjectConfig: (config: ProjectConfig) => void;
+/**
+ * Returns project config, or defaults if not configured.
+ * When warnIfMissing is true and no config exists, prints a small warning once to stderr and proceeds with defaults.
+ */
+export declare const getProjectConfig: (options?: {
+    warnIfMissing?: boolean;
+}) => ProjectConfig;
+export { EDITOR_DEFAULT_PATHS, DEFAULT_EDITOR, DEFAULT_OUTPUT_PATH };

package/dist/auth/project-config.js

@@ -0,0 +1,63 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+const PROJECT_CONFIG_DIR = '.bitcompass';
+const PROJECT_CONFIG_FILE = 'config.json';
+const EDITOR_DEFAULT_PATHS = {
+    vscode: '.vscode/rules',
+    cursor: '.cursor/rules',
+    antigrativity: '.antigrativity/rules',
+    claudecode: '.claude/rules',
+};
+const DEFAULT_EDITOR = 'cursor';
+const DEFAULT_OUTPUT_PATH = EDITOR_DEFAULT_PATHS[DEFAULT_EDITOR];
+const getProjectConfigPath = () => {
+    const cwd = process.cwd();
+    return join(cwd, PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILE);
+};
+export const getProjectConfigDir = () => join(process.cwd(), PROJECT_CONFIG_DIR);
+export const getEditorDefaultPath = (editor) => EDITOR_DEFAULT_PATHS[editor];
+export const loadProjectConfig = () => {
+    const path = getProjectConfigPath();
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        const data = JSON.parse(raw);
+        const editor = data.editor;
+        const outputPath = typeof data.outputPath === 'string' ? data.outputPath : undefined;
+        if (editor && Object.keys(EDITOR_DEFAULT_PATHS).includes(editor) && outputPath) {
+            return { editor, outputPath };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+};
+const ensureProjectConfigDir = () => {
+    const dir = join(process.cwd(), PROJECT_CONFIG_DIR);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { mode: 0o755, recursive: true });
+    }
+};
+export const saveProjectConfig = (config) => {
+    ensureProjectConfigDir();
+    const path = getProjectConfigPath();
+    writeFileSync(path, JSON.stringify(config, null, 2), { mode: 0o644 });
+};
+let warnedMissing = false;
+/**
+ * Returns project config, or defaults if not configured.
+ * When warnIfMissing is true and no config exists, prints a small warning once to stderr and proceeds with defaults.
+ */
+export const getProjectConfig = (options) => {
+    const config = loadProjectConfig();
+    if (config)
+        return config;
+    if (options?.warnIfMissing && !warnedMissing) {
+        warnedMissing = true;
+        process.stderr.write('[bitcompass] No project config found (.bitcompass/config.json). Using defaults. Run "bitcompass init" to configure.\n');
+    }
+    return { editor: DEFAULT_EDITOR, outputPath: DEFAULT_OUTPUT_PATH };
+};
+export { EDITOR_DEFAULT_PATHS, DEFAULT_EDITOR, DEFAULT_OUTPUT_PATH };

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -0,0 +1,56 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getEditorDefaultPath, loadProjectConfig, saveProjectConfig, getProjectConfigDir, } from '../auth/project-config.js';
+const EDITOR_CHOICES = [
+    { name: 'VSCode', value: 'vscode' },
+    { name: 'Cursor', value: 'cursor' },
+    { name: 'Antigrativity', value: 'antigrativity' },
+    { name: 'Claude Code', value: 'claudecode' },
+];
+const GITIGNORE_ENTRY = '.bitcompass';
+const ensureGitignoreEntry = () => {
+    const gitignorePath = join(process.cwd(), '.gitignore');
+    if (!existsSync(gitignorePath)) {
+        writeFileSync(gitignorePath, `${GITIGNORE_ENTRY}\n`, 'utf-8');
+        return;
+    }
+    const content = readFileSync(gitignorePath, 'utf-8');
+    const lines = content.split(/\r?\n/);
+    const hasEntry = lines.some((line) => line.trim() === GITIGNORE_ENTRY);
+    if (hasEntry)
+        return;
+    const trimmed = content.trimEnd();
+    const suffix = trimmed ? '\n' : '';
+    writeFileSync(gitignorePath, `${trimmed}${suffix}\n${GITIGNORE_ENTRY}\n`, 'utf-8');
+};
+export const runInit = async () => {
+    const existing = loadProjectConfig();
+    const answers = await inquirer.prompt([
+        {
+            name: 'editor',
+            message: 'Editor / AI provider',
+            type: 'list',
+            choices: EDITOR_CHOICES,
+            default: existing?.editor ?? 'cursor',
+        },
+        {
+            name: 'outputPath',
+            message: 'Folder for rules/docs/commands output',
+            type: 'input',
+            default: ({ editor }) => getEditorDefaultPath(editor),
+        },
+    ]);
+    const config = {
+        editor: answers.editor,
+        outputPath: answers.outputPath.trim() || getEditorDefaultPath(answers.editor),
+    };
+    saveProjectConfig(config);
+    ensureGitignoreEntry();
+    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.');
+};

package/dist/commands/log.d.ts

@@ -6,4 +6,19 @@ import type { TimeFrame } from '../lib/git-analysis.js';
 export declare const buildAndPushActivityLog: (timeFrame: TimeFrame, cwd: string) => Promise<{
     id: string;
 }>;
-export declare const runLog: () => Promise<void>;
+/**
+ * Push an activity log for a custom date or date range. timeFrame is used for display (day/week/month).
+ */
+export declare const buildAndPushActivityLogWithPeriod: (period: {
+    period_start: string;
+    period_end: string;
+    since: string;
+}, timeFrame: TimeFrame, cwd: string) => Promise<{
+    id: string;
+}>;
+/** Parse argv for log: [start] or [start, end] or [start, '-', end]. Returns { start, end } or null for interactive. */
+export declare const parseLogArgs: (args: string[]) => {
+    start: string;
+    end?: string;
+} | null;
+export declare const runLog: (args?: string[]) => Promise<void>;

package/dist/commands/log.js

@@ -2,7 +2,7 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import { insertActivityLog } from '../api/client.js';
 import { loadCredentials } from '../auth/config.js';
-import { getRepoRoot, getRepoSummary, getGitAnalysis, getPeriodForTimeFrame, } from '../lib/git-analysis.js';
+import { getRepoRoot, getRepoSummary, getGitAnalysis, getPeriodForTimeFrame, getPeriodForCustomDates, } from '../lib/git-analysis.js';
 /**
  * Shared logic: resolve repo, compute period, gather summary + git analysis, insert log.
  * Used by both CLI and MCP. Returns the created log id or throws.
@@ -25,7 +25,55 @@ export const buildAndPushActivityLog = async (timeFrame, cwd) => {
     const created = await insertActivityLog(payload);
     return { id: created.id };
 };
-export const runLog = async () => {
+/**
+ * Push an activity log for a custom date or date range. timeFrame is used for display (day/week/month).
+ */
+export const buildAndPushActivityLogWithPeriod = async (period, timeFrame, cwd) => {
+    const repoRoot = getRepoRoot(cwd);
+    if (!repoRoot) {
+        throw new Error('Not a git repository. Run from a project with git or pass a valid repo path.');
+    }
+    const repo_summary = getRepoSummary(repoRoot);
+    const git_analysis = getGitAnalysis(repoRoot, period.since, period.period_end);
+    const payload = {
+        time_frame: timeFrame,
+        period_start: period.period_start,
+        period_end: period.period_end,
+        repo_summary: repo_summary,
+        git_analysis: git_analysis,
+    };
+    const created = await insertActivityLog(payload);
+    return { id: created.id };
+};
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+const isDateArg = (s) => ISO_DATE.test(s.trim());
+/** Parse argv for log: [start] or [start, end] or [start, '-', end]. Returns { start, end } or null for interactive. */
+export const parseLogArgs = (args) => {
+    const trimmed = args.map((a) => a.trim()).filter(Boolean);
+    if (trimmed.length === 0)
+        return null;
+    if (trimmed.length === 1 && isDateArg(trimmed[0]))
+        return { start: trimmed[0] };
+    if (trimmed.length === 2 && isDateArg(trimmed[0]) && isDateArg(trimmed[1])) {
+        return { start: trimmed[0], end: trimmed[1] };
+    }
+    if (trimmed.length === 3 && isDateArg(trimmed[0]) && trimmed[1] === '-' && isDateArg(trimmed[2])) {
+        return { start: trimmed[0], end: trimmed[2] };
+    }
+    throw new Error('Usage: bitcompass log [YYYY-MM-DD] or bitcompass log [YYYY-MM-DD] [YYYY-MM-DD] or bitcompass log [YYYY-MM-DD] - [YYYY-MM-DD]');
+};
+/** Choose time_frame for a custom range by span (day ≤ 1, week ≤ 7, else month). */
+const timeFrameForRange = (start, end) => {
+    const a = new Date(start);
+    const b = new Date(end);
+    const days = Math.round((b.getTime() - a.getTime()) / (24 * 60 * 60 * 1000)) + 1;
+    if (days <= 1)
+        return 'day';
+    if (days <= 7)
+        return 'week';
+    return 'month';
+};
+export const runLog = async (args = []) => {
     if (!loadCredentials()) {
         console.error(chalk.red('Not logged in. Run bitcompass login.'));
         process.exit(1);
@@ -36,6 +84,14 @@ export const runLog = async () => {
         console.error(chalk.red('Not a git repository. Run this command from a project with git.'));
         process.exit(1);
     }
+    const parsed = parseLogArgs(args);
+    if (parsed) {
+        const period = getPeriodForCustomDates(parsed.start, parsed.end);
+        const timeFrame = parsed.end ? timeFrameForRange(parsed.start, parsed.end) : 'day';
+        const result = await buildAndPushActivityLogWithPeriod(period, timeFrame, cwd);
+        console.log(chalk.green('Log saved.'), chalk.dim(result.id));
+        return;
+    }
     const choice = await inquirer.prompt([
         {
             name: 'time_frame',

package/dist/commands/rules.js

@@ -1,8 +1,10 @@
 import inquirer from 'inquirer';
 import ora from 'ora';
 import chalk from 'chalk';
-import { writeFileSync } from 'fs';
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
 import { loadCredentials } from '../auth/config.js';
+import { getProjectConfig } from '../auth/project-config.js';
 import { searchRules, fetchRules, getRuleById, insertRule } from '../api/client.js';
 export const runRulesSearch = async (query) => {
     if (!loadCredentials()) {
@@ -67,7 +69,10 @@ export const runRulesPull = async (id) => {
         console.error(chalk.red('Rule not found.'));
         process.exit(1);
     }
-    const filename = `rule-${rule.id}.md`;
+    const { outputPath } = getProjectConfig({ warnIfMissing: true });
+    const outDir = join(process.cwd(), outputPath);
+    mkdirSync(outDir, { recursive: true });
+    const filename = join(outDir, `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);

package/dist/commands/solutions.js

@@ -1,8 +1,10 @@
 import inquirer from 'inquirer';
 import ora from 'ora';
 import chalk from 'chalk';
-import { writeFileSync } from 'fs';
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
 import { loadCredentials } from '../auth/config.js';
+import { getProjectConfig } from '../auth/project-config.js';
 import { searchRules, fetchRules, getRuleById, insertRule } from '../api/client.js';
 export const runSolutionsSearch = async (query) => {
     if (!loadCredentials()) {
@@ -55,7 +57,10 @@ export const runSolutionsPull = async (id) => {
         console.error(chalk.red('Solution not found.'));
         process.exit(1);
     }
-    const filename = `solution-${rule.id}.md`;
+    const { outputPath } = getProjectConfig({ warnIfMissing: true });
+    const outDir = join(process.cwd(), outputPath);
+    mkdirSync(outDir, { recursive: true });
+    const filename = join(outDir, `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);

package/dist/index.js

@@ -3,6 +3,7 @@ import 'dotenv/config';
 import chalk from 'chalk';
 import { Command } from 'commander';
 import { runConfigGet, runConfigList, runConfigSet } from './commands/config-cmd.js';
+import { runInit } from './commands/init.js';
 import { runLogin } from './commands/login.js';
 import { runLogout } from './commands/logout.js';
 import { runMcpStart, runMcpStatus } from './commands/mcp.js';
@@ -28,9 +29,13 @@ program
     .description('Show current user (email)')
     .action(runWhoami);
 program
-    .command('log')
-    .description('Collect repo summary and git activity, then push to your activity logs')
-    .action(() => runLog().catch(handleErr));
+    .command('init')
+    .description('Configure project: editor/AI provider and output folder for rules/docs/commands')
+    .action(() => runInit().catch(handleErr));
+program
+    .command('log [dates...]')
+    .description('Collect repo summary and git activity, then push to your activity logs. Optional: bitcompass log YYYY-MM-DD or bitcompass log YYYY-MM-DD YYYY-MM-DD')
+    .action((dates) => runLog(dates ?? []).catch(handleErr));
 const configCmd = program.command('config').description('Show or set config');
 configCmd.action(runConfigList);
 configCmd.command('list').description('List config values').action(runConfigList);

package/dist/lib/git-analysis.d.ts

@@ -36,7 +36,13 @@ export declare const getRepoSummary: (repoRoot: string) => RepoSummary;
  * period_end is now; period_start and since are the start of the window.
  */
 export declare const getPeriodForTimeFrame: (timeFrame: TimeFrame) => PeriodBounds;
+/**
+ * Compute period for custom date(s). Single date = that day; two dates = range (inclusive).
+ * period_end is end of last day (23:59:59.999).
+ */
+export declare const getPeriodForCustomDates: (startDateStr: string, endDateStr?: string) => PeriodBounds;
 /**
  * Run git log for the given period and return structured analysis.
+ * If until is provided, commits are limited to the range [since, until].
  */
-export declare const getGitAnalysis: (repoRoot: string, since: string) => GitAnalysisResult;
+export declare const getGitAnalysis: (repoRoot: string, since: string, until?: string) => GitAnalysisResult;

package/dist/lib/git-analysis.js

@@ -72,12 +72,61 @@ export const getPeriodForTimeFrame = (timeFrame) => {
         since,
     };
 };
+/**
+ * Parse an ISO date string (YYYY-MM-DD) to Date at start of day (UTC).
+ */
+const parseDate = (s) => {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s.trim());
+    if (!match)
+        return null;
+    const y = parseInt(match[1], 10);
+    const m = parseInt(match[2], 10) - 1;
+    const d = parseInt(match[3], 10);
+    const date = new Date(Date.UTC(y, m, d, 0, 0, 0, 0));
+    if (date.getUTCFullYear() !== y || date.getUTCMonth() !== m || date.getUTCDate() !== d)
+        return null;
+    return date;
+};
+/**
+ * Compute period for custom date(s). Single date = that day; two dates = range (inclusive).
+ * period_end is end of last day (23:59:59.999).
+ */
+export const getPeriodForCustomDates = (startDateStr, endDateStr) => {
+    const startDate = parseDate(startDateStr);
+    if (!startDate) {
+        throw new Error(`Invalid start date: ${startDateStr}. Use YYYY-MM-DD.`);
+    }
+    let periodEnd;
+    if (endDateStr !== undefined && endDateStr.trim() !== '') {
+        const endDate = parseDate(endDateStr);
+        if (!endDate)
+            throw new Error(`Invalid end date: ${endDateStr}. Use YYYY-MM-DD.`);
+        if (endDate < startDate)
+            throw new Error('End date must be on or after start date.');
+        periodEnd = new Date(endDate);
+        periodEnd.setUTCHours(23, 59, 59, 999);
+    }
+    else {
+        periodEnd = new Date(startDate);
+        periodEnd.setUTCHours(23, 59, 59, 999);
+    }
+    const period_start = new Date(startDate);
+    period_start.setUTCHours(0, 0, 0, 0);
+    const since = period_start.toISOString();
+    return {
+        period_start: period_start.toISOString(),
+        period_end: periodEnd.toISOString(),
+        since,
+    };
+};
 /**
  * Run git log for the given period and return structured analysis.
+ * If until is provided, commits are limited to the range [since, until].
  */
-export const getGitAnalysis = (repoRoot, since) => {
+export const getGitAnalysis = (repoRoot, since, until) => {
     const format = '%H%x00%s%x00%ci';
-    const logOut = exec(`git log --since="${since}" --format=${format}`, repoRoot);
+    const untilArg = until ? ` --until="${until}"` : '';
+    const logOut = exec(`git log --since="${since}"${untilArg} --format=${format}`, repoRoot);
     const commits = [];
     if (logOut) {
         for (const line of logOut.split('\n')) {
@@ -91,7 +140,7 @@ export const getGitAnalysis = (repoRoot, since) => {
             }
         }
     }
-    const shortstatOut = exec(`git log --since="${since}" --shortstat --format=`, repoRoot);
+    const shortstatOut = exec(`git log --since="${since}"${untilArg} --shortstat --format=`, repoRoot);
     let insertions = 0;
     let deletions = 0;
     if (shortstatOut) {

package/dist/mcp/server.js

@@ -1,6 +1,7 @@
 import { AUTH_REQUIRED_MSG, insertRule, searchRules } from '../api/client.js';
 import { buildAndPushActivityLog } from '../commands/log.js';
 import { loadCredentials } from '../auth/config.js';
+import { getProjectConfig } from '../auth/project-config.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
@@ -276,6 +277,7 @@ function createStdioServer() {
     };
 }
 export const startMcpServer = async () => {
+    getProjectConfig({ warnIfMissing: true });
     const server = createStdioServer();
     await server.connect();
     // Do not exit when not logged in: Cursor needs the process alive to complete

package/dist/types.d.ts

@@ -30,6 +30,12 @@ export interface StoredCredentials {
         email?: string;
     };
 }
+export type EditorProvider = 'vscode' | 'cursor' | 'antigrativity' | 'claudecode';
+export interface ProjectConfig {
+    editor: EditorProvider;
+    /** Folder for rules/docs/commands output (e.g. .cursor/rules/) */
+    outputPath: string;
+}
 export interface BitcompassConfig {
     apiUrl?: string;
     supabaseUrl?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bitcompass",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "BitCompass CLI - rules, solutions, and MCP server",
   "type": "module",
   "bin": {