drift-ai 0.1.0

package/README.md

@@ -0,0 +1,145 @@
+# drift
+
+> Track how your code drifts from the plan during AI coding sessions
+
+When you vibe code with AI (Cursor, Copilot, Claude, etc.), the implementation often drifts from the original ticket. `drift` captures what actually happened and keeps context for the next session.
+
+## The Problem
+
+1. PO writes PRD → creates Jira tickets
+2. Developer takes ticket, vibes with AI
+3. AI changes things — sometimes a lot
+4. Ticket still says the old plan
+5. Next task has wrong context
+6. AI doesn't know what actually happened
+
+## The Solution
+
+```bash
+drift start PROJ-123      # Start session, link to ticket
+# ... vibe code with your AI ...
+drift sync                # AI summarizes what happened, updates CONTEXT.md
+```
+
+## Installation
+
+```bash
+npm install -g drift-ai
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/mersall/drift-ai
+cd drift-ai
+npm install
+npm run build
+npm link
+```
+
+## Setup
+
+```bash
+# In your project repo
+drift init
+
+# Get free API key from https://console.groq.com
+drift config --groq-key gsk_...
+
+# (Optional) Configure Jira
+drift config --jira-url https://yourteam.atlassian.net \
+             --jira-email you@email.com \
+             --jira-token your-api-token
+```
+
+## Usage
+
+### Start a session
+
+```bash
+drift start                    # Start without ticket
+drift start PROJ-123           # Link to Jira ticket
+drift start PROJ-123 -m "Adding auth flow"  # With plan description
+```
+
+### Check status
+
+```bash
+drift status                   # See what's changed since session start
+```
+
+### End session & sync
+
+```bash
+drift sync                     # Generate summary, update CONTEXT.md, post to Jira
+drift sync --no-push           # Skip Jira posting
+drift sync -m "Also refactored the utils"  # Add notes
+```
+
+### View history
+
+```bash
+drift log                      # Last 5 sessions
+drift log -n 10                # Last 10 sessions
+```
+
+## CONTEXT.md
+
+After each sync, `drift` updates `CONTEXT.md` in your repo:
+
+```markdown
+# Project Context
+
+## Session: 2024-02-03 (PROJ-123)
+
+**What happened:**
+Implemented JWT authentication with refresh tokens. Switched from localStorage 
+to httpOnly cookies for better security.
+
+**Decisions made:**
+- Using cookies over localStorage for token storage
+- Added rate limiting on auth endpoints (wasn't in spec)
+- Skipped "remember me" — needs product decision
+
+**Drift from plan:**
+- Original spec said localStorage, we changed to cookies
+- Added refresh token rotation (not in original ticket)
+
+**For next session:**
+- Auth context lives in /src/auth/
+- Token refresh is handled in axios interceptor
+- Still need: password reset flow
+```
+
+This file becomes context for your next AI session — paste it or let your AI read it.
+
+## Environment Variables
+
+Instead of `drift config`, you can use environment variables:
+
+```bash
+export GROQ_API_KEY=gsk_...
+export JIRA_URL=https://yourteam.atlassian.net
+export JIRA_EMAIL=you@email.com
+export JIRA_TOKEN=your-api-token
+```
+
+## How It Works
+
+1. `drift start` saves the current git SHA
+2. You code with your AI assistant
+3. `drift sync` gets the git diff since start
+4. Groq (Llama 3.3 70B) analyzes what changed and generates a structured summary
+5. CONTEXT.md is updated with the session info
+6. (Optional) Summary is posted as a comment on the Jira ticket
+
+## Why Groq?
+
+- **100% free** — no credit card needed
+- **Fast** — responses in <1 second
+- **Good quality** — Llama 3.3 70B is excellent for code analysis
+- **No subscription required** — just sign up and get a key
+
+## License
+
+MIT

package/dist/commands/config.d.ts

@@ -0,0 +1,9 @@
+interface ConfigOptions {
+    jiraUrl?: string;
+    jiraEmail?: string;
+    jiraToken?: string;
+    groqKey?: string;
+    show?: boolean;
+}
+export declare function configCommand(options?: ConfigOptions): Promise<void>;
+export {};

package/dist/commands/config.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import { setGroqKey, setJiraConfig, getGroqKey, getJiraConfig } from '../lib/config.js';
+export async function configCommand(options) {
+    // If no options, show config
+    if (!options || Object.keys(options).length === 0 || options.show) {
+        console.log(chalk.bold('drift configuration'));
+        console.log(chalk.dim('─'.repeat(40)));
+        console.log();
+        const groqKey = getGroqKey();
+        const jira = getJiraConfig();
+        console.log(chalk.bold('Groq API (free):'));
+        if (groqKey) {
+            console.log(chalk.green('  ✓ Configured') + chalk.dim(` (***${groqKey.slice(-4)})`));
+        }
+        else {
+            console.log(chalk.red('  ✗ Not configured'));
+            console.log(chalk.dim('    Get free key: https://console.groq.com'));
+            console.log(chalk.dim('    Set with: drift config --groq-key <key>'));
+        }
+        console.log();
+        console.log(chalk.bold('Jira:'));
+        if (jira.url && jira.email && jira.token) {
+            console.log(chalk.green('  ✓ Configured'));
+            console.log(chalk.dim(`    URL: ${jira.url}`));
+            console.log(chalk.dim(`    Email: ${jira.email}`));
+        }
+        else {
+            console.log(chalk.yellow('  ○ Not configured') + chalk.dim(' (optional)'));
+            console.log(chalk.dim('    Set with: drift config --jira-url <url> --jira-email <email> --jira-token <token>'));
+        }
+        console.log();
+        return;
+    }
+    let updated = false;
+    if (options.groqKey) {
+        setGroqKey(options.groqKey);
+        console.log(chalk.green('✓ Groq API key saved'));
+        updated = true;
+    }
+    if (options.jiraUrl || options.jiraEmail || options.jiraToken) {
+        setJiraConfig(options.jiraUrl, options.jiraEmail, options.jiraToken);
+        if (options.jiraUrl)
+            console.log(chalk.green('✓ Jira URL saved'));
+        if (options.jiraEmail)
+            console.log(chalk.green('✓ Jira email saved'));
+        if (options.jiraToken)
+            console.log(chalk.green('✓ Jira token saved'));
+        updated = true;
+    }
+    if (updated) {
+        console.log();
+        console.log(chalk.dim('Run `drift config --show` to see current configuration.'));
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from 'fs';
+import { join } from 'path';
+import { isGitRepo } from '../lib/git.js';
+import { getLocalConfigPath, saveLocalConfig } from '../lib/config.js';
+export async function initCommand() {
+    // Check if we're in a git repo
+    if (!(await isGitRepo())) {
+        console.log(chalk.red('Error: Not a git repository.'));
+        console.log(chalk.dim('Run this command from the root of a git repository.'));
+        process.exit(1);
+    }
+    const driftDir = join(process.cwd(), '.drift');
+    const configPath = getLocalConfigPath();
+    // Check if already initialized
+    if (existsSync(configPath)) {
+        console.log(chalk.yellow('drift is already initialized in this repository.'));
+        return;
+    }
+    // Create .drift directory
+    if (!existsSync(driftDir)) {
+        mkdirSync(driftDir, { recursive: true });
+    }
+    // Create initial config
+    saveLocalConfig({
+        initialized: true,
+        sessions: [],
+    });
+    // Create .drift/sessions.json for history
+    const sessionsPath = join(driftDir, 'sessions.json');
+    writeFileSync(sessionsPath, '[]');
+    // Add .drift to .gitignore if not already there
+    const gitignorePath = join(process.cwd(), '.gitignore');
+    if (existsSync(gitignorePath)) {
+        const gitignore = readFileSync(gitignorePath, 'utf-8');
+        if (!gitignore.includes('.drift')) {
+            appendFileSync(gitignorePath, '\n# drift session data\n.drift/\n');
+            console.log(chalk.dim('Added .drift/ to .gitignore'));
+        }
+    }
+    else {
+        writeFileSync(gitignorePath, '# drift session data\n.drift/\n');
+        console.log(chalk.dim('Created .gitignore with .drift/'));
+    }
+    console.log(chalk.green('✓ drift initialized'));
+    console.log();
+    console.log('Next steps:');
+    console.log(chalk.dim('  1. Get free Groq API key:'));
+    console.log(chalk.cyan('     https://console.groq.com'));
+    console.log(chalk.dim('  2. Configure the key:'));
+    console.log(chalk.cyan('     drift config --groq-key <your-key>'));
+    console.log(chalk.dim('  3. (Optional) Configure Jira:'));
+    console.log(chalk.cyan('     drift config --jira-url https://yourteam.atlassian.net --jira-email you@email.com --jira-token <token>'));
+    console.log(chalk.dim('  4. Start a coding session:'));
+    console.log(chalk.cyan('     drift start PROJ-123'));
+}

package/dist/commands/log.d.ts

@@ -0,0 +1,5 @@
+interface LogOptions {
+    number?: string;
+}
+export declare function logCommand(options?: LogOptions): Promise<void>;
+export {};

package/dist/commands/log.js

@@ -0,0 +1,44 @@
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getLocalConfig } from '../lib/config.js';
+import { isGitRepo } from '../lib/git.js';
+export async function logCommand(options) {
+    if (!(await isGitRepo())) {
+        console.log(chalk.red('Error: Not a git repository.'));
+        process.exit(1);
+    }
+    const config = getLocalConfig();
+    if (!config.initialized) {
+        console.log(chalk.red('Error: drift not initialized. Run: drift init'));
+        process.exit(1);
+    }
+    const sessionsPath = join(process.cwd(), '.drift', 'sessions.json');
+    if (!existsSync(sessionsPath)) {
+        console.log(chalk.dim('No sessions recorded yet.'));
+        return;
+    }
+    const sessions = JSON.parse(readFileSync(sessionsPath, 'utf-8'));
+    const count = parseInt(options?.number || '5', 10);
+    if (sessions.length === 0) {
+        console.log(chalk.dim('No sessions recorded yet.'));
+        return;
+    }
+    console.log(chalk.bold('drift session history'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log();
+    sessions.slice(0, count).forEach((session, i) => {
+        const date = new Date(session.date).toLocaleString();
+        const ticket = session.ticket ? chalk.cyan(session.ticket) : chalk.dim('no ticket');
+        console.log(chalk.bold(`${i + 1}. ${date}`));
+        console.log(chalk.dim('   Ticket: ') + ticket);
+        console.log(chalk.dim('   SHA: ') + session.startSha.slice(0, 7));
+        if (session.summary) {
+            console.log(chalk.dim('   Summary: ') + session.summary.slice(0, 80) + (session.summary.length > 80 ? '...' : ''));
+        }
+        console.log();
+    });
+    if (sessions.length > count) {
+        console.log(chalk.dim(`Showing ${count} of ${sessions.length} sessions. Use -n to see more.`));
+    }
+}

package/dist/commands/start.d.ts

@@ -0,0 +1,5 @@
+interface StartOptions {
+    message?: string;
+}
+export declare function startCommand(ticket?: string, options?: StartOptions): Promise<void>;
+export {};

package/dist/commands/start.js

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getLocalConfig, setActiveSession, getActiveSession } from '../lib/config.js';
+import { getCurrentSha, getCurrentBranch, isGitRepo } from '../lib/git.js';
+import { getTicket, extractTicketKey, isJiraConfigured } from '../integrations/jira.js';
+export async function startCommand(ticket, options) {
+    // Check if initialized
+    if (!(await isGitRepo())) {
+        console.log(chalk.red('Error: Not a git repository.'));
+        process.exit(1);
+    }
+    const config = getLocalConfig();
+    if (!config.initialized) {
+        console.log(chalk.red('Error: drift not initialized. Run: drift init'));
+        process.exit(1);
+    }
+    // Check for active session
+    const activeSession = getActiveSession();
+    if (activeSession) {
+        console.log(chalk.yellow('Warning: A session is already active.'));
+        console.log(chalk.dim(`Started at: ${activeSession.startedAt}`));
+        if (activeSession.ticket) {
+            console.log(chalk.dim(`Ticket: ${activeSession.ticket}`));
+        }
+        console.log();
+        console.log('Run ' + chalk.cyan('drift sync') + ' to end the current session first.');
+        return;
+    }
+    const spinner = ora('Starting session...').start();
+    try {
+        const [sha, branch] = await Promise.all([getCurrentSha(), getCurrentBranch()]);
+        let ticketKey;
+        let ticketContext;
+        // Try to extract and fetch ticket info
+        if (ticket) {
+            ticketKey = extractTicketKey(ticket) || ticket;
+            if (isJiraConfigured()) {
+                try {
+                    const ticketInfo = await getTicket(ticketKey);
+                    ticketContext = `${ticketInfo.summary}\n${ticketInfo.description}`;
+                    spinner.text = `Linked to ${ticketKey}: ${ticketInfo.summary}`;
+                }
+                catch (e) {
+                    spinner.warn(`Could not fetch ticket ${ticketKey} from Jira`);
+                }
+            }
+        }
+        const session = {
+            startedAt: new Date().toISOString(),
+            startSha: sha,
+            ticket: ticketKey,
+            plannedWork: options?.message || ticketContext,
+        };
+        setActiveSession(session);
+        spinner.succeed(chalk.green('Session started'));
+        console.log();
+        console.log(chalk.dim(`Branch: ${branch}`));
+        console.log(chalk.dim(`Starting SHA: ${sha.slice(0, 7)}`));
+        if (ticketKey) {
+            console.log(chalk.dim(`Ticket: ${ticketKey}`));
+        }
+        if (options?.message) {
+            console.log(chalk.dim(`Plan: ${options.message}`));
+        }
+        console.log();
+        console.log('Go vibe with your AI. When done, run: ' + chalk.cyan('drift sync'));
+    }
+    catch (error) {
+        spinner.fail('Failed to start session');
+        console.error(error);
+        process.exit(1);
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function statusCommand(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,70 @@
+import chalk from 'chalk';
+import { getLocalConfig, getActiveSession } from '../lib/config.js';
+import { getStatusSince, isGitRepo, getCurrentSha, getCurrentBranch } from '../lib/git.js';
+export async function statusCommand() {
+    if (!(await isGitRepo())) {
+        console.log(chalk.red('Error: Not a git repository.'));
+        process.exit(1);
+    }
+    const config = getLocalConfig();
+    if (!config.initialized) {
+        console.log(chalk.red('Error: drift not initialized. Run: drift init'));
+        process.exit(1);
+    }
+    const session = getActiveSession();
+    console.log(chalk.bold('drift status'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log();
+    if (!session) {
+        const [sha, branch] = await Promise.all([getCurrentSha(), getCurrentBranch()]);
+        console.log(chalk.dim('No active session.'));
+        console.log();
+        console.log(chalk.dim(`Branch: ${branch}`));
+        console.log(chalk.dim(`HEAD: ${sha.slice(0, 7)}`));
+        console.log();
+        console.log('Start a session with: ' + chalk.cyan('drift start [ticket]'));
+        return;
+    }
+    const status = await getStatusSince(session.startSha);
+    console.log(chalk.green('● Session active'));
+    console.log();
+    console.log(chalk.dim('Started: ') + new Date(session.startedAt).toLocaleString());
+    if (session.ticket) {
+        console.log(chalk.dim('Ticket: ') + session.ticket);
+    }
+    if (session.plannedWork) {
+        console.log(chalk.dim('Plan: ') + session.plannedWork.slice(0, 100) + (session.plannedWork.length > 100 ? '...' : ''));
+    }
+    console.log();
+    console.log(chalk.dim('Branch: ') + status.branch);
+    console.log(chalk.dim('Started at: ') + session.startSha.slice(0, 7));
+    console.log(chalk.dim('Current: ') + status.currentSha.slice(0, 7));
+    console.log();
+    if (status.changedFiles.length === 0 && status.commits.length === 0) {
+        console.log(chalk.yellow('No changes yet.'));
+    }
+    else {
+        console.log(chalk.bold(`Changes since session start:`));
+        console.log();
+        if (status.commits.length > 0) {
+            console.log(chalk.dim('Commits:'));
+            status.commits.slice(0, 10).forEach((c) => console.log(chalk.dim('  ') + c));
+            if (status.commits.length > 10) {
+                console.log(chalk.dim(`  ... and ${status.commits.length - 10} more`));
+            }
+            console.log();
+        }
+        console.log(chalk.dim('Files changed:'));
+        status.changedFiles.slice(0, 15).forEach((f) => console.log(chalk.dim('  ') + f));
+        if (status.changedFiles.length > 15) {
+            console.log(chalk.dim(`  ... and ${status.changedFiles.length - 15} more`));
+        }
+        console.log();
+        if (status.diffStat) {
+            console.log(chalk.dim('Stats:'));
+            console.log(status.diffStat.split('\n').slice(-3).join('\n'));
+        }
+    }
+    console.log();
+    console.log('When done, run: ' + chalk.cyan('drift sync'));
+}

package/dist/commands/sync.d.ts

@@ -0,0 +1,6 @@
+interface SyncOptions {
+    message?: string;
+    push?: boolean;
+}
+export declare function syncCommand(options?: SyncOptions): Promise<void>;
+export {};

package/dist/commands/sync.js

@@ -0,0 +1,122 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getLocalConfig, clearActiveSession, getActiveSession } from '../lib/config.js';
+import { getDiffSince, getDiffStatSince, getCommitsSince, getChangedFiles, isGitRepo } from '../lib/git.js';
+import { summarizeSession } from '../lib/ai.js';
+import { updateContext } from '../lib/context.js';
+import { addComment, isJiraConfigured } from '../integrations/jira.js';
+function getSessionsPath() {
+    return join(process.cwd(), '.drift', 'sessions.json');
+}
+function saveToHistory(entry) {
+    const path = getSessionsPath();
+    let history = [];
+    if (existsSync(path)) {
+        history = JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    history.unshift(entry);
+    // Keep last 50 sessions
+    history = history.slice(0, 50);
+    writeFileSync(path, JSON.stringify(history, null, 2));
+}
+export async function syncCommand(options) {
+    if (!(await isGitRepo())) {
+        console.log(chalk.red('Error: Not a git repository.'));
+        process.exit(1);
+    }
+    const config = getLocalConfig();
+    if (!config.initialized) {
+        console.log(chalk.red('Error: drift not initialized. Run: drift init'));
+        process.exit(1);
+    }
+    const session = getActiveSession();
+    if (!session) {
+        console.log(chalk.yellow('No active session.'));
+        console.log('Start one with: ' + chalk.cyan('drift start [ticket]'));
+        return;
+    }
+    const spinner = ora('Analyzing changes...').start();
+    try {
+        // Get all the git info
+        const [diff, diffStat, commits, changedFiles] = await Promise.all([
+            getDiffSince(session.startSha),
+            getDiffStatSince(session.startSha),
+            getCommitsSince(session.startSha),
+            getChangedFiles(session.startSha),
+        ]);
+        if (changedFiles.length === 0 && commits.length === 0) {
+            spinner.warn('No changes detected since session start.');
+            const cleared = clearActiveSession();
+            console.log(chalk.dim('Session ended without changes.'));
+            return;
+        }
+        spinner.text = 'Generating summary with AI...';
+        // Generate AI summary
+        const summary = await summarizeSession(diff, diffStat, commits, changedFiles, session.plannedWork, undefined // TODO: fetch ticket context if available
+        );
+        spinner.text = 'Updating CONTEXT.md...';
+        // Update CONTEXT.md
+        updateContext({
+            date: new Date().toISOString().split('T')[0],
+            ticket: session.ticket,
+            summary,
+        });
+        // Save to history
+        saveToHistory({
+            date: session.startedAt,
+            ticket: session.ticket,
+            startSha: session.startSha,
+            summary: summary.whatHappened,
+        });
+        // Post to Jira if configured and ticket exists
+        if (options?.push !== false && session.ticket && isJiraConfigured()) {
+            spinner.text = `Posting to Jira (${session.ticket})...`;
+            try {
+                await addComment(session.ticket, `🤖 Drift Session Summary:\n\n${summary.ticketComment}`);
+                spinner.succeed('Session synced & posted to Jira');
+            }
+            catch (e) {
+                spinner.warn('Session synced, but failed to post to Jira');
+                console.error(chalk.dim(String(e)));
+            }
+        }
+        else {
+            spinner.succeed('Session synced');
+        }
+        // Clear the active session
+        clearActiveSession();
+        // Print summary
+        console.log();
+        console.log(chalk.bold('📝 Session Summary'));
+        console.log(chalk.dim('─'.repeat(50)));
+        console.log();
+        console.log(chalk.bold('What happened:'));
+        console.log(summary.whatHappened);
+        console.log();
+        if (summary.decisions.length > 0) {
+            console.log(chalk.bold('Decisions:'));
+            summary.decisions.forEach((d) => console.log(chalk.dim('  • ') + d));
+            console.log();
+        }
+        if (summary.drift.length > 0) {
+            console.log(chalk.bold('Drift from plan:'));
+            summary.drift.forEach((d) => console.log(chalk.yellow('  ⚡ ') + d));
+            console.log();
+        }
+        if (summary.forNextSession.length > 0) {
+            console.log(chalk.bold('For next session:'));
+            summary.forNextSession.forEach((d) => console.log(chalk.cyan('  → ') + d));
+            console.log();
+        }
+        console.log(chalk.dim('─'.repeat(50)));
+        console.log(chalk.dim(`Files changed: ${changedFiles.length} | Commits: ${commits.length}`));
+        console.log(chalk.green('✓ CONTEXT.md updated'));
+    }
+    catch (error) {
+        spinner.fail('Failed to sync session');
+        console.error(error);
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { startCommand } from './commands/start.js';
+import { syncCommand } from './commands/sync.js';
+import { statusCommand } from './commands/status.js';
+import { logCommand } from './commands/log.js';
+import { configCommand } from './commands/config.js';
+const program = new Command();
+program
+    .name('drift')
+    .description('Track how your code drifts from the plan during AI coding sessions')
+    .version('0.1.0');
+program
+    .command('init')
+    .description('Initialize drift in current repository')
+    .action(initCommand);
+program
+    .command('start [ticket]')
+    .description('Start a coding session, optionally linked to a ticket')
+    .option('-m, --message <message>', 'What you plan to work on')
+    .action(startCommand);
+program
+    .command('sync')
+    .description('End session, generate summary, update context')
+    .option('-m, --message <message>', 'Additional notes about the session')
+    .option('--no-push', 'Skip pushing to Jira')
+    .action(syncCommand);
+program
+    .command('status')
+    .description('Show what changed since last sync')
+    .action(statusCommand);
+program
+    .command('log')
+    .description('View history of coding sessions')
+    .option('-n, --number <count>', 'Number of sessions to show', '5')
+    .action(logCommand);
+program
+    .command('config')
+    .description('Configure drift settings')
+    .option('--jira-url <url>', 'Jira instance URL')
+    .option('--jira-email <email>', 'Jira account email')
+    .option('--jira-token <token>', 'Jira API token')
+    .option('--groq-key <key>', 'Groq API key (free at console.groq.com)')
+    .option('--show', 'Show current configuration')
+    .action(configCommand);
+program.parse();

package/dist/integrations/jira.d.ts

@@ -0,0 +1,10 @@
+export interface JiraTicket {
+    key: string;
+    summary: string;
+    description: string;
+    status: string;
+}
+export declare function getTicket(ticketKey: string): Promise<JiraTicket>;
+export declare function addComment(ticketKey: string, comment: string): Promise<void>;
+export declare function isJiraConfigured(): boolean;
+export declare function extractTicketKey(input: string): string | null;

package/dist/integrations/jira.js

@@ -0,0 +1,74 @@
+import { getJiraConfig } from '../lib/config.js';
+function getAuthHeader() {
+    const { email, token } = getJiraConfig();
+    if (!email || !token) {
+        throw new Error('Jira not configured. Run: drift config --jira-url <url> --jira-email <email> --jira-token <token>');
+    }
+    return 'Basic ' + Buffer.from(`${email}:${token}`).toString('base64');
+}
+function getBaseUrl() {
+    const { url } = getJiraConfig();
+    if (!url) {
+        throw new Error('Jira URL not configured. Run: drift config --jira-url <url>');
+    }
+    return url.replace(/\/$/, '');
+}
+export async function getTicket(ticketKey) {
+    const baseUrl = getBaseUrl();
+    const response = await fetch(`${baseUrl}/rest/api/3/issue/${ticketKey}`, {
+        headers: {
+            Authorization: getAuthHeader(),
+            'Content-Type': 'application/json',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch ticket ${ticketKey}: ${response.status}`);
+    }
+    const data = await response.json();
+    return {
+        key: data.key,
+        summary: data.fields.summary,
+        description: data.fields.description?.content?.[0]?.content?.[0]?.text || '',
+        status: data.fields.status.name,
+    };
+}
+export async function addComment(ticketKey, comment) {
+    const baseUrl = getBaseUrl();
+    const response = await fetch(`${baseUrl}/rest/api/3/issue/${ticketKey}/comment`, {
+        method: 'POST',
+        headers: {
+            Authorization: getAuthHeader(),
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            body: {
+                type: 'doc',
+                version: 1,
+                content: [
+                    {
+                        type: 'paragraph',
+                        content: [
+                            {
+                                type: 'text',
+                                text: comment,
+                            },
+                        ],
+                    },
+                ],
+            },
+        }),
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Failed to add comment to ${ticketKey}: ${response.status} - ${error}`);
+    }
+}
+export function isJiraConfigured() {
+    const { url, email, token } = getJiraConfig();
+    return !!(url && email && token);
+}
+export function extractTicketKey(input) {
+    // Match common Jira ticket patterns: PROJ-123, ABC-1, etc.
+    const match = input.match(/[A-Z][A-Z0-9]+-\d+/i);
+    return match ? match[0].toUpperCase() : null;
+}

package/dist/lib/ai.d.ts

@@ -0,0 +1,8 @@
+export interface SessionSummary {
+    whatHappened: string;
+    decisions: string[];
+    drift: string[];
+    forNextSession: string[];
+    ticketComment: string;
+}
+export declare function summarizeSession(diff: string, diffStat: string, commits: string[], changedFiles: string[], plannedWork?: string, ticketContext?: string): Promise<SessionSummary>;

package/dist/lib/ai.js

@@ -0,0 +1,73 @@
+import Groq from 'groq-sdk';
+import { getGroqKey } from './config.js';
+export async function summarizeSession(diff, diffStat, commits, changedFiles, plannedWork, ticketContext) {
+    const apiKey = getGroqKey();
+    if (!apiKey) {
+        throw new Error('Groq API key not configured. Run: drift config --groq-key <key>\nGet free key at: https://console.groq.com');
+    }
+    const client = new Groq({ apiKey });
+    const prompt = `You are analyzing a coding session. Based on the git diff and context, create a summary.
+
+${plannedWork ? `## What was planned\n${plannedWork}\n` : ''}
+${ticketContext ? `## Ticket context\n${ticketContext}\n` : ''}
+
+## Files changed
+${changedFiles.join('\n')}
+
+## Diff stats
+${diffStat}
+
+## Commits
+${commits.length > 0 ? commits.join('\n') : 'No commits yet (uncommitted changes)'}
+
+## Diff (truncated to 8000 chars)
+${diff.slice(0, 8000)}
+
+---
+
+Analyze this session and respond in JSON format only (no markdown, no code blocks):
+{
+  "whatHappened": "2-3 sentence summary of what was actually implemented",
+  "decisions": ["list of technical decisions made", "each as a short bullet"],
+  "drift": ["ways the implementation differed from the plan", "empty array if no drift or no plan provided"],
+  "forNextSession": ["important context for continuing this work", "where to find key code", "what's left to do"],
+  "ticketComment": "A concise comment suitable for posting on the Jira ticket (2-4 sentences)"
+}
+
+Be specific about file paths, function names, and technical details. Focus on what would help a developer (or AI) continue this work tomorrow.
+Respond with ONLY valid JSON, no extra text.`;
+    const response = await client.chat.completions.create({
+        model: 'llama-3.3-70b-versatile',
+        messages: [{ role: 'user', content: prompt }],
+        max_tokens: 1500,
+        temperature: 0.3,
+    });
+    const content = response.choices[0]?.message?.content;
+    if (!content) {
+        throw new Error('Empty response from Groq');
+    }
+    try {
+        // Extract JSON from response (handle markdown code blocks if present)
+        let jsonStr = content;
+        const jsonMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+        if (jsonMatch) {
+            jsonStr = jsonMatch[1];
+        }
+        // Also try to find JSON object directly
+        const objectMatch = jsonStr.match(/\{[\s\S]*\}/);
+        if (objectMatch) {
+            jsonStr = objectMatch[0];
+        }
+        return JSON.parse(jsonStr.trim());
+    }
+    catch {
+        // Fallback if JSON parsing fails
+        return {
+            whatHappened: content.slice(0, 500),
+            decisions: [],
+            drift: [],
+            forNextSession: [],
+            ticketComment: 'Session completed. See CONTEXT.md for details.',
+        };
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,25 @@
+export interface SessionState {
+    startedAt: string;
+    startSha: string;
+    ticket?: string;
+    plannedWork?: string;
+}
+export interface DriftConfig {
+    initialized: boolean;
+    sessions: SessionState[];
+}
+export declare function getLocalConfigPath(): string;
+export declare function getLocalConfig(): DriftConfig;
+export declare function saveLocalConfig(config: DriftConfig): void;
+export declare function getActiveSession(): SessionState | null;
+export declare function setActiveSession(session: SessionState | null): void;
+export declare function clearActiveSession(): SessionState | null;
+export declare function getGroqKey(): string | undefined;
+export declare function setGroqKey(key: string): void;
+export declare function getJiraConfig(): {
+    url?: string;
+    email?: string;
+    token?: string;
+};
+export declare function setJiraConfig(url?: string, email?: string, token?: string): void;
+export declare function showConfig(): Record<string, unknown>;

package/dist/lib/config.js

@@ -0,0 +1,73 @@
+import Conf from 'conf';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+// Global config (API keys, Jira URL)
+const globalConfig = new Conf({
+    projectName: 'drift',
+    schema: {
+        groqKey: { type: 'string' },
+        jiraUrl: { type: 'string' },
+        jiraEmail: { type: 'string' },
+        jiraToken: { type: 'string' },
+    },
+});
+// Local config (per-repo, stored in .drift/config.json)
+export function getLocalConfigPath() {
+    return join(process.cwd(), '.drift', 'config.json');
+}
+export function getLocalConfig() {
+    const configPath = getLocalConfigPath();
+    if (existsSync(configPath)) {
+        return JSON.parse(readFileSync(configPath, 'utf-8'));
+    }
+    return { initialized: false, sessions: [] };
+}
+export function saveLocalConfig(config) {
+    const configPath = getLocalConfigPath();
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+export function getActiveSession() {
+    const config = getLocalConfig();
+    return config.sessions.length > 0 ? config.sessions[config.sessions.length - 1] : null;
+}
+export function setActiveSession(session) {
+    const config = getLocalConfig();
+    if (session) {
+        config.sessions.push(session);
+    }
+    saveLocalConfig(config);
+}
+export function clearActiveSession() {
+    const config = getLocalConfig();
+    const session = config.sessions.pop() || null;
+    saveLocalConfig(config);
+    return session;
+}
+// Global config getters/setters
+export function getGroqKey() {
+    return process.env.GROQ_API_KEY || globalConfig.get('groqKey');
+}
+export function setGroqKey(key) {
+    globalConfig.set('groqKey', key);
+}
+export function getJiraConfig() {
+    return {
+        url: process.env.JIRA_URL || globalConfig.get('jiraUrl'),
+        email: process.env.JIRA_EMAIL || globalConfig.get('jiraEmail'),
+        token: process.env.JIRA_TOKEN || globalConfig.get('jiraToken'),
+    };
+}
+export function setJiraConfig(url, email, token) {
+    if (url)
+        globalConfig.set('jiraUrl', url);
+    if (email)
+        globalConfig.set('jiraEmail', email);
+    if (token)
+        globalConfig.set('jiraToken', token);
+}
+export function showConfig() {
+    return {
+        groqKey: getGroqKey() ? '***' + (getGroqKey()?.slice(-4) || '') : undefined,
+        jira: getJiraConfig(),
+    };
+}

package/dist/lib/context.d.ts

@@ -0,0 +1,11 @@
+import { SessionSummary } from './ai.js';
+export interface SessionEntry {
+    date: string;
+    ticket?: string;
+    summary: SessionSummary;
+}
+export declare function getContextPath(): string;
+export declare function contextExists(): boolean;
+export declare function readContext(): string;
+export declare function updateContext(entry: SessionEntry): void;
+export declare function getLatestSessionContext(): string | null;

package/dist/lib/context.js

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+const CONTEXT_FILE = 'CONTEXT.md';
+const MAX_PREVIOUS_SESSIONS = 5;
+export function getContextPath() {
+    return join(process.cwd(), CONTEXT_FILE);
+}
+export function contextExists() {
+    return existsSync(getContextPath());
+}
+export function readContext() {
+    const path = getContextPath();
+    if (existsSync(path)) {
+        return readFileSync(path, 'utf-8');
+    }
+    return '';
+}
+function formatSessionEntry(entry) {
+    let content = `## Session: ${entry.date}`;
+    if (entry.ticket) {
+        content += ` (${entry.ticket})`;
+    }
+    content += '\n\n';
+    content += `**What happened:**\n${entry.summary.whatHappened}\n\n`;
+    if (entry.summary.decisions.length > 0) {
+        content += `**Decisions made:**\n${entry.summary.decisions.map((d) => `- ${d}`).join('\n')}\n\n`;
+    }
+    if (entry.summary.drift.length > 0) {
+        content += `**Drift from plan:**\n${entry.summary.drift.map((d) => `- ${d}`).join('\n')}\n\n`;
+    }
+    if (entry.summary.forNextSession.length > 0) {
+        content += `**For next session:**\n${entry.summary.forNextSession.map((d) => `- ${d}`).join('\n')}\n\n`;
+    }
+    return content;
+}
+export function updateContext(entry) {
+    const path = getContextPath();
+    let existingContent = '';
+    let previousSessions = [];
+    if (existsSync(path)) {
+        existingContent = readFileSync(path, 'utf-8');
+        // Extract previous sessions
+        const sessionMatches = existingContent.match(/## Session:[\s\S]*?(?=## Session:|## Previous Sessions|$)/g);
+        if (sessionMatches) {
+            previousSessions = sessionMatches.slice(0, MAX_PREVIOUS_SESSIONS - 1);
+        }
+    }
+    // Build new context file
+    let newContent = `# Project Context
+
+> This file is auto-generated by drift. It helps AI assistants understand recent changes.
+> Last updated: ${new Date().toISOString()}
+
+# Latest Session
+
+${formatSessionEntry(entry)}`;
+    if (previousSessions.length > 0) {
+        newContent += `# Previous Sessions
+
+${previousSessions.join('\n---\n\n')}`;
+    }
+    writeFileSync(path, newContent);
+}
+export function getLatestSessionContext() {
+    const content = readContext();
+    if (!content)
+        return null;
+    // Extract the latest session section
+    const match = content.match(/# Latest Session\s*([\s\S]*?)(?=# Previous Sessions|$)/);
+    if (match) {
+        return match[1].trim();
+    }
+    return null;
+}

package/dist/lib/git.d.ts

@@ -0,0 +1,16 @@
+export declare function isGitRepo(): Promise<boolean>;
+export declare function getCurrentSha(): Promise<string>;
+export declare function getCurrentBranch(): Promise<string>;
+export declare function getDiffSince(sha: string): Promise<string>;
+export declare function getDiffStatSince(sha: string): Promise<string>;
+export declare function getCommitsSince(sha: string): Promise<string[]>;
+export declare function getChangedFiles(sha: string): Promise<string[]>;
+export declare function getRepoRoot(): Promise<string>;
+export interface GitStatus {
+    currentSha: string;
+    branch: string;
+    changedFiles: string[];
+    diffStat: string;
+    commits: string[];
+}
+export declare function getStatusSince(startSha: string): Promise<GitStatus>;

package/dist/lib/git.js

@@ -0,0 +1,82 @@
+import { simpleGit } from 'simple-git';
+const git = simpleGit();
+export async function isGitRepo() {
+    try {
+        await git.revparse(['--git-dir']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getCurrentSha() {
+    const result = await git.revparse(['HEAD']);
+    return result.trim();
+}
+export async function getCurrentBranch() {
+    const result = await git.revparse(['--abbrev-ref', 'HEAD']);
+    return result.trim();
+}
+export async function getDiffSince(sha) {
+    try {
+        // Compare start SHA to working directory (includes uncommitted changes)
+        const diff = await git.diff([sha]);
+        return diff;
+    }
+    catch {
+        // Fallback: get all uncommitted changes
+        const diff = await git.diff();
+        return diff;
+    }
+}
+export async function getDiffStatSince(sha) {
+    try {
+        // Compare start SHA to working directory (includes uncommitted changes)
+        const stat = await git.diff([sha, '--stat']);
+        return stat;
+    }
+    catch {
+        const stat = await git.diff(['--stat']);
+        return stat;
+    }
+}
+export async function getCommitsSince(sha) {
+    try {
+        const log = await git.log({ from: sha, to: 'HEAD' });
+        return log.all.map((commit) => `${commit.hash.slice(0, 7)} ${commit.message}`);
+    }
+    catch {
+        return [];
+    }
+}
+export async function getChangedFiles(sha) {
+    try {
+        // Compare start SHA to working directory (includes uncommitted changes)
+        const diff = await git.diff([sha, '--name-only']);
+        return diff.split('\n').filter(Boolean);
+    }
+    catch {
+        const diff = await git.diff(['--name-only']);
+        return diff.split('\n').filter(Boolean);
+    }
+}
+export async function getRepoRoot() {
+    const root = await git.revparse(['--show-toplevel']);
+    return root.trim();
+}
+export async function getStatusSince(startSha) {
+    const [currentSha, branch, changedFiles, diffStat, commits] = await Promise.all([
+        getCurrentSha(),
+        getCurrentBranch(),
+        getChangedFiles(startSha),
+        getDiffStatSince(startSha),
+        getCommitsSince(startSha),
+    ]);
+    return {
+        currentSha,
+        branch,
+        changedFiles,
+        diffStat,
+        commits,
+    };
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "drift-ai",
+  "version": "0.1.0",
+  "description": "Track how your code drifts from the plan during AI coding sessions",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "drift": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "start": "node dist/index.js",
+    "lint": "eslint src/",
+    "prepublishOnly": "npm run build",
+    "drift": "node dist/index.js"
+  },
+  "keywords": [
+    "ai",
+    "coding",
+    "context",
+    "jira",
+    "github",
+    "cli",
+    "cursor",
+    "copilot",
+    "vibe-coding"
+  ],
+  "author": "mersall",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mersall/drift-ai"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "conf": "^13.0.1",
+    "dotenv": "^16.4.7",
+    "groq-sdk": "^0.37.0",
+    "ora": "^8.1.1",
+    "simple-git": "^3.27.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.2"
+  }
+}