codesession-cli 1.0.0

package/src/formatters.ts

@@ -0,0 +1,152 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { Session, SessionStats, FileChange, Commit } from './types';
+import { formatDistanceToNow, format } from 'date-fns';
+
+export function formatDuration(seconds: number): string {
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  }
+  return `${minutes}m`;
+}
+
+export function formatCost(cost: number): string {
+  return `$${cost.toFixed(2)}`;
+}
+
+export function displaySession(session: Session): void {
+  console.log(chalk.bold.cyan(`\nSession: ${session.name}\n`));
+
+  const table = new Table({
+    head: [chalk.cyan.bold('Metric'), chalk.cyan.bold('Value')],
+    style: { head: [], border: [] },
+  });
+
+  table.push(
+    ['Status', session.status === 'active' ? chalk.green('Active') : chalk.gray('Completed')],
+    ['Started', format(new Date(session.startTime), 'MMM dd, yyyy HH:mm')],
+  );
+
+  if (session.endTime) {
+    table.push(['Ended', format(new Date(session.endTime), 'MMM dd, yyyy HH:mm')]);
+  }
+
+  if (session.duration) {
+    table.push(['Duration', chalk.white(formatDuration(session.duration))]);
+  }
+
+  table.push(
+    ['Files Changed', chalk.white(session.filesChanged.toString())],
+    ['Commits', chalk.white(session.commits.toString())],
+    ['AI Tokens', chalk.white(session.aiTokens.toLocaleString())],
+    ['AI Cost', chalk.yellow(formatCost(session.aiCost))],
+  );
+
+  if (session.notes) {
+    table.push(['Notes', chalk.gray(session.notes)]);
+  }
+
+  console.log(table.toString());
+}
+
+export function displaySessions(sessions: Session[]): void {
+  if (sessions.length === 0) {
+    console.log(chalk.yellow('\nNo sessions found.\n'));
+    return;
+  }
+
+  const table = new Table({
+    head: [
+      chalk.cyan.bold('ID'),
+      chalk.cyan.bold('Name'),
+      chalk.cyan.bold('Started'),
+      chalk.cyan.bold('Duration'),
+      chalk.cyan.bold('Files'),
+      chalk.cyan.bold('Commits'),
+      chalk.cyan.bold('AI Cost'),
+    ],
+    style: { head: [], border: [] },
+  });
+
+  for (const session of sessions) {
+    table.push([
+      chalk.gray(`#${session.id}`),
+      session.status === 'active' ? chalk.green(session.name) : chalk.white(session.name),
+      formatDistanceToNow(new Date(session.startTime), { addSuffix: true }),
+      session.duration ? formatDuration(session.duration) : chalk.gray('ongoing'),
+      session.filesChanged.toString(),
+      session.commits.toString(),
+      chalk.yellow(formatCost(session.aiCost)),
+    ]);
+  }
+
+  console.log('\n' + table.toString() + '\n');
+}
+
+export function displayStats(stats: SessionStats): void {
+  console.log(chalk.bold.cyan('\nOverall Stats\n'));
+
+  const table = new Table({
+    head: [chalk.cyan.bold('Metric'), chalk.cyan.bold('Value')],
+    style: { head: [], border: [] },
+  });
+
+  table.push(
+    ['Total Sessions', chalk.white(stats.totalSessions.toLocaleString())],
+    ['Total Time', chalk.white(formatDuration(stats.totalTime))],
+    ['Average Session', chalk.white(formatDuration(stats.avgSessionTime))],
+    ['Files Changed', chalk.white(stats.totalFiles.toLocaleString())],
+    ['Commits', chalk.white(stats.totalCommits.toLocaleString())],
+    ['Total AI Cost', chalk.yellow(formatCost(stats.totalAICost))],
+  );
+
+  console.log(table.toString() + '\n');
+}
+
+export function displayFileChanges(changes: FileChange[]): void {
+  if (changes.length === 0) return;
+
+  console.log(chalk.bold.cyan('\nFile Changes\n'));
+
+  const table = new Table({
+    head: [chalk.cyan.bold('Type'), chalk.cyan.bold('File'), chalk.cyan.bold('Time')],
+    style: { head: [], border: [] },
+  });
+
+  for (const change of changes) {
+    const typeColor = change.changeType === 'created' ? chalk.green : 
+                      change.changeType === 'modified' ? chalk.yellow : chalk.red;
+    
+    table.push([
+      typeColor(change.changeType),
+      change.filePath,
+      formatDistanceToNow(new Date(change.timestamp), { addSuffix: true }),
+    ]);
+  }
+
+  console.log(table.toString() + '\n');
+}
+
+export function displayCommits(commits: Commit[]): void {
+  if (commits.length === 0) return;
+
+  console.log(chalk.bold.cyan('\nCommits\n'));
+
+  const table = new Table({
+    head: [chalk.cyan.bold('Hash'), chalk.cyan.bold('Message'), chalk.cyan.bold('Time')],
+    style: { head: [], border: [] },
+  });
+
+  for (const commit of commits) {
+    table.push([
+      chalk.gray(commit.hash),
+      commit.message,
+      formatDistanceToNow(new Date(commit.timestamp), { addSuffix: true }),
+    ]);
+  }
+
+  console.log(table.toString() + '\n');
+}

package/src/git.ts

@@ -0,0 +1,44 @@
+import { simpleGit, SimpleGit } from 'simple-git';
+import { addCommit } from './db';
+
+let git: SimpleGit;
+let lastCommitHash: string | null = null;
+
+export function initGit(cwd: string): void {
+  git = simpleGit(cwd);
+}
+
+export async function checkForNewCommits(sessionId: number): Promise<void> {
+  if (!git) return;
+
+  try {
+    const log = await git.log({ maxCount: 1 });
+    if (log.latest && log.latest.hash !== lastCommitHash) {
+      lastCommitHash = log.latest.hash;
+      
+      addCommit({
+        sessionId,
+        hash: log.latest.hash.substring(0, 7),
+        message: log.latest.message,
+        timestamp: new Date().toISOString(),
+      });
+    }
+  } catch (error) {
+    // Not a git repo or no commits yet
+  }
+}
+
+export async function getGitInfo(): Promise<{ branch: string; hasChanges: boolean } | null> {
+  if (!git) return null;
+
+  try {
+    const branch = await git.revparse(['--abbrev-ref', 'HEAD']);
+    const status = await git.status();
+    return {
+      branch: branch.trim(),
+      hasChanges: !status.isClean(),
+    };
+  } catch (error) {
+    return null;
+  }
+}

package/src/index.ts

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { 
+  createSession, 
+  getActiveSession, 
+  endSession, 
+  getSession, 
+  getSessions, 
+  getStats,
+  getFileChanges,
+  getCommits,
+  addAIUsage
+} from './db';
+import { initGit, checkForNewCommits, getGitInfo } from './git';
+import { startWatcher, stopWatcher } from './watcher';
+import { 
+  displaySession, 
+  displaySessions, 
+  displayStats,
+  displayFileChanges,
+  displayCommits
+} from './formatters';
+
+const program = new Command();
+
+program
+  .name('devsession')
+  .description('Track your AI coding sessions: time, files, commits, AI costs')
+  .version('1.0.0');
+
+// Start command
+program
+  .command('start')
+  .description('Start a new coding session')
+  .argument('<name>', 'Session name')
+  .action(async (name: string) => {
+    const active = getActiveSession();
+    if (active) {
+      console.log(chalk.yellow(`\nSession "${active.name}" is already active.`));
+      console.log(chalk.gray('End it with: ds end\n'));
+      return;
+    }
+
+    const cwd = process.cwd();
+    const sessionId = createSession({
+      name,
+      startTime: new Date().toISOString(),
+      workingDirectory: cwd,
+      filesChanged: 0,
+      commits: 0,
+      aiCost: 0,
+      aiTokens: 0,
+      status: 'active',
+    });
+
+    // Initialize git tracking
+    initGit(cwd);
+    
+    // Start file watcher
+    startWatcher(sessionId, cwd);
+
+    // Check for commits every 10 seconds
+    const gitInterval = setInterval(async () => {
+      await checkForNewCommits(sessionId);
+    }, 10000);
+
+    // Store interval ID
+    (global as any).gitInterval = gitInterval;
+
+    const gitInfo = await getGitInfo();
+    
+    console.log(chalk.green(`\n✓ Session started: ${name}`));
+    if (gitInfo) {
+      console.log(chalk.gray(`  Branch: ${gitInfo.branch}`));
+    }
+    console.log(chalk.gray(`  Directory: ${cwd}`));
+    console.log(chalk.gray('\n  Tracking: files, commits, AI usage'));
+    console.log(chalk.gray('  End with: ds end\n'));
+  });
+
+// End command
+program
+  .command('end')
+  .description('End the active session')
+  .option('-n, --notes <notes>', 'Session notes')
+  .action((options) => {
+    const session = getActiveSession();
+    if (!session) {
+      console.log(chalk.yellow('\nNo active session.\n'));
+      return;
+    }
+
+    // Stop tracking
+    stopWatcher();
+    if ((global as any).gitInterval) {
+      clearInterval((global as any).gitInterval);
+    }
+
+    endSession(session.id!, new Date().toISOString(), options.notes);
+
+    const updated = getSession(session.id!);
+    if (updated) {
+      console.log(chalk.green('\n✓ Session ended\n'));
+      displaySession(updated);
+    }
+  });
+
+// Show command
+program
+  .command('show')
+  .description('Show session details')
+  .argument('[id]', 'Session ID (defaults to last session)')
+  .option('--files', 'Show file changes')
+  .option('--commits', 'Show commits')
+  .action((id: string | undefined, options) => {
+    let session;
+    
+    if (id) {
+      session = getSession(parseInt(id));
+    } else {
+      const sessions = getSessions(1);
+      session = sessions[0];
+    }
+
+    if (!session) {
+      console.log(chalk.yellow('\nSession not found.\n'));
+      return;
+    }
+
+    displaySession(session);
+
+    if (options.files) {
+      const files = getFileChanges(session.id!);
+      displayFileChanges(files);
+    }
+
+    if (options.commits) {
+      const commits = getCommits(session.id!);
+      displayCommits(commits);
+    }
+  });
+
+// List command
+program
+  .command('list')
+  .alias('ls')
+  .description('List recent sessions')
+  .option('-l, --limit <number>', 'Number of sessions to show', parseInt, 10)
+  .action((options) => {
+    const sessions = getSessions(options.limit);
+    displaySessions(sessions);
+  });
+
+// Stats command
+program
+  .command('stats')
+  .description('Show overall statistics')
+  .action(() => {
+    const stats = getStats();
+    displayStats(stats);
+  });
+
+// Log AI usage command
+program
+  .command('log-ai')
+  .description('Log AI usage for active session')
+  .requiredOption('-p, --provider <provider>', 'AI provider')
+  .requiredOption('-m, --model <model>', 'Model name')
+  .requiredOption('-t, --tokens <tokens>', 'Total tokens', parseInt)
+  .requiredOption('-c, --cost <cost>', 'Cost in dollars', parseFloat)
+  .action((options) => {
+    const session = getActiveSession();
+    if (!session) {
+      console.log(chalk.yellow('\nNo active session. Start one with: ds start <name>\n'));
+      return;
+    }
+
+    addAIUsage({
+      sessionId: session.id!,
+      provider: options.provider,
+      model: options.model,
+      tokens: options.tokens,
+      cost: options.cost,
+      timestamp: new Date().toISOString(),
+    });
+
+    console.log(chalk.green(`\n✓ Logged AI usage: ${options.tokens.toLocaleString()} tokens, $${options.cost.toFixed(2)}\n`));
+  });
+
+// Status command
+program
+  .command('status')
+  .description('Show active session status')
+  .action(() => {
+    const session = getActiveSession();
+    if (!session) {
+      console.log(chalk.yellow('\nNo active session.\n'));
+      return;
+    }
+
+    displaySession(session);
+  });
+
+program.parse();

package/src/types.ts

@@ -0,0 +1,49 @@
+export interface Session {
+  id?: number;
+  name: string;
+  startTime: string;
+  endTime?: string;
+  duration?: number; // in seconds
+  workingDirectory: string;
+  filesChanged: number;
+  commits: number;
+  aiCost: number;
+  aiTokens: number;
+  notes?: string;
+  status: 'active' | 'completed';
+}
+
+export interface FileChange {
+  id?: number;
+  sessionId: number;
+  filePath: string;
+  changeType: 'created' | 'modified' | 'deleted';
+  timestamp: string;
+}
+
+export interface Commit {
+  id?: number;
+  sessionId: number;
+  hash: string;
+  message: string;
+  timestamp: string;
+}
+
+export interface AIUsage {
+  id?: number;
+  sessionId: number;
+  provider: string;
+  model: string;
+  tokens: number;
+  cost: number;
+  timestamp: string;
+}
+
+export interface SessionStats {
+  totalSessions: number;
+  totalTime: number;
+  totalFiles: number;
+  totalCommits: number;
+  totalAICost: number;
+  avgSessionTime: number;
+}

package/src/watcher.ts

@@ -0,0 +1,52 @@
+import chokidar from 'chokidar';
+import { relative } from 'path';
+import { addFileChange } from './db';
+
+let watcher: chokidar.FSWatcher | null = null;
+const changedFiles = new Set<string>();
+
+export function startWatcher(sessionId: number, cwd: string): void {
+  if (watcher) return;
+
+  watcher = chokidar.watch(cwd, {
+    ignored: /(^|[\/\\])\..|(node_modules|dist|build|\.git)/,
+    persistent: true,
+    ignoreInitial: true,
+  });
+
+  watcher
+    .on('add', (path) => handleChange(sessionId, path, cwd, 'created'))
+    .on('change', (path) => handleChange(sessionId, path, cwd, 'modified'))
+    .on('unlink', (path) => handleChange(sessionId, path, cwd, 'deleted'));
+}
+
+export function stopWatcher(): void {
+  if (watcher) {
+    watcher.close();
+    watcher = null;
+    changedFiles.clear();
+  }
+}
+
+function handleChange(
+  sessionId: number,
+  path: string,
+  cwd: string,
+  changeType: 'created' | 'modified' | 'deleted'
+): void {
+  const relativePath = relative(cwd, path);
+  
+  // Deduplicate rapid changes to same file
+  const key = `${relativePath}-${changeType}`;
+  if (changedFiles.has(key)) return;
+  
+  changedFiles.add(key);
+  setTimeout(() => changedFiles.delete(key), 1000);
+
+  addFileChange({
+    sessionId,
+    filePath: relativePath,
+    changeType,
+    timestamp: new Date().toISOString(),
+  });
+}

package/test.ts

@@ -0,0 +1,4 @@
+// Test file to trigger file watcher
+export function hello() {
+  return 'Hello from test!';
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}