feat(cli): add logging to git and GitHub indexers

- GitIndexer: add logger option with progress logging
- GitHubIndexer: add logger and onProgress callback
- CLI git/gh commands: add --verbose flag
- Spinner shows progress: 'Embedding X/Y commits/docs (N%)'

Example output:
[git-indexer] Starting git commit extraction {limit: 500}
[git-indexer] Extracted commits {commits: 500}
[git-indexer] Embedded 320/500 commits {batch: 10}
[github-indexer] Fetched GitHub documents {documents: 150}
[github-indexer] Document breakdown {issues: 100, prs: 50}

Author: prosdev

packages/cli/src/commands/gh.ts

@@ -5,10 +5,11 @@
 
 import { getStorageFilePaths, getStoragePath } from '@lytics/dev-agent-core';
 import { GitHubIndexer } from '@lytics/dev-agent-subagents';
+import { createLogger } from '@lytics/kero';
 import chalk from 'chalk';
 import { Command } from 'commander';
 import ora from 'ora';
-import { logger } from '../utils/logger.js';
+import { keroLogger, logger } from '../utils/logger.js';
 
 /**
  * Create GitHub indexer with centralized storage
@@ -52,9 +53,15 @@ export const ghCommand = new Command('gh')
       .option('--prs-only', 'Index only pull requests')
       .option('--state <state>', 'Filter by state (open, closed, merged, all)', 'all')
       .option('--limit <number>', 'Limit number of items to fetch', Number.parseInt)
+      .option('-v, --verbose', 'Verbose output', false)
       .action(async (options) => {
         const spinner = ora('Loading configuration...').start();
 
+        // Create logger for indexing
+        const indexLogger = options.verbose
+          ? createLogger({ level: 'debug', format: 'pretty' })
+          : keroLogger.child({ command: 'gh-index' });
+
         try {
           spinner.text = 'Initializing indexers...';
 
@@ -82,6 +89,14 @@ export const ghCommand = new Command('gh')
             types: types as ('issue' | 'pull_request')[],
             state: state as ('open' | 'closed' | 'merged')[] | undefined,
             limit: options.limit,
+            logger: indexLogger,
+            onProgress: (progress) => {
+              if (progress.phase === 'fetching') {
+                spinner.text = 'Fetching GitHub issues/PRs...';
+              } else if (progress.phase === 'embedding') {
+                spinner.text = `Embedding ${progress.documentsProcessed}/${progress.totalDocuments} GitHub docs`;
+              }
+            },
           });
 
           spinner.succeed(chalk.green('GitHub data indexed!'));

packages/cli/src/commands/git.ts

@@ -10,10 +10,11 @@ import {
   LocalGitExtractor,
   VectorStorage,
 } from '@lytics/dev-agent-core';
+import { createLogger } from '@lytics/kero';
 import chalk from 'chalk';
 import { Command } from 'commander';
 import ora from 'ora';
-import { logger } from '../utils/logger.js';
+import { keroLogger, logger } from '../utils/logger.js';
 
 /**
  * Create Git indexer with centralized storage
@@ -51,9 +52,15 @@ export const gitCommand = new Command('git')
         '--since <date>',
         'Only index commits after this date (e.g., "2024-01-01", "6 months ago")'
       )
+      .option('-v, --verbose', 'Verbose output', false)
       .action(async (options) => {
         const spinner = ora('Loading configuration...').start();
 
+        // Create logger for indexing
+        const indexLogger = options.verbose
+          ? createLogger({ level: 'debug', format: 'pretty' })
+          : keroLogger.child({ command: 'git-index' });
+
         try {
           spinner.text = 'Initializing git indexer...';
 
@@ -64,6 +71,13 @@ export const gitCommand = new Command('git')
           const stats = await indexer.index({
             limit: options.limit,
             since: options.since,
+            logger: indexLogger,
+            onProgress: (progress) => {
+              if (progress.phase === 'storing' && progress.totalCommits > 0) {
+                const pct = Math.round((progress.commitsProcessed / progress.totalCommits) * 100);
+                spinner.text = `Embedding ${progress.commitsProcessed}/${progress.totalCommits} commits (${pct}%)`;
+              }
+            },
           });
 
           spinner.succeed(chalk.green('Git history indexed!'));

packages/cli/src/commands/index.ts

@@ -193,7 +193,16 @@ export const indexCommand = new Command('index')
           vectorStorage: gitVectorStore,
         });
 
-        gitStats = await gitIndexer.index({ limit: options.gitLimit });
+        gitStats = await gitIndexer.index({
+          limit: options.gitLimit,
+          logger: indexLogger,
+          onProgress: (progress) => {
+            if (progress.phase === 'storing' && progress.totalCommits > 0) {
+              const pct = Math.round((progress.commitsProcessed / progress.totalCommits) * 100);
+              spinner.text = `Embedding ${progress.commitsProcessed}/${progress.totalCommits} commits (${pct}%)`;
+            }
+          },
+        });
         await gitVectorStore.close();
 
         spinner.succeed(chalk.green('Git history indexed!'));
@@ -219,6 +228,14 @@ export const indexCommand = new Command('index')
 
         ghStats = await ghIndexer.index({
           limit: options.ghLimit,
+          logger: indexLogger,
+          onProgress: (progress) => {
+            if (progress.phase === 'fetching') {
+              spinner.text = 'Fetching GitHub issues/PRs...';
+            } else if (progress.phase === 'embedding') {
+              spinner.text = `Embedding ${progress.documentsProcessed}/${progress.totalDocuments} GitHub docs`;
+            }
+          },
         });
         spinner.succeed(chalk.green('GitHub indexed!'));
         logger.log('');

packages/cli/src/utils/logger.ts

@@ -5,7 +5,7 @@
 import { createLogger, type Logger, type LogLevel } from '@lytics/kero';
 
 // Create a logger with pretty output and icons
-const keroLogger = createLogger({
+export const keroLogger = createLogger({
   preset: 'development',
   format: 'pretty',
 });

packages/core/src/git/indexer.ts

@@ -4,6 +4,7 @@
  * Indexes git commits into the vector store for semantic search.
  */
 
+import type { Logger } from '@lytics/kero';
 import type { VectorStorage } from '../vector';
 import type { EmbeddingDocument } from '../vector/types';
 import type { GitExtractor } from './extractor';
@@ -39,6 +40,8 @@ export interface GitIndexOptions {
   noMerges?: boolean;
   /** Progress callback */
   onProgress?: (progress: GitIndexProgress) => void;
+  /** Logger instance */
+  logger?: Logger;
 }
 
 /**
@@ -81,6 +84,9 @@ export class GitIndexer {
 
     const limit = options.limit ?? this.commitLimit;
     const onProgress = options.onProgress;
+    const logger = options.logger?.child({ component: 'git-indexer' });
+
+    logger?.info({ limit }, 'Starting git commit extraction');
 
     // Phase 1: Extract commits
     onProgress?.({
@@ -101,9 +107,11 @@ export class GitIndexer {
     let commits: GitCommit[];
     try {
       commits = await this.extractor.getCommits(extractOptions);
+      logger?.info({ commits: commits.length }, 'Extracted commits');
     } catch (error) {
       const message = `Failed to extract commits: ${error instanceof Error ? error.message : String(error)}`;
       errors.push(message);
+      logger?.error({ error: message }, 'Failed to extract commits');
       return {
         commitsIndexed: 0,
         durationMs: Date.now() - startTime,
@@ -112,6 +120,7 @@ export class GitIndexer {
     }
 
     if (commits.length === 0) {
+      logger?.info('No commits to index');
       onProgress?.({
         phase: 'complete',
         commitsProcessed: 0,
@@ -126,6 +135,7 @@ export class GitIndexer {
     }
 
     // Phase 2: Prepare documents for embedding
+    logger?.debug({ commits: commits.length }, 'Preparing commit documents for embedding');
     onProgress?.({
       phase: 'embedding',
       commitsProcessed: 0,
@@ -136,6 +146,10 @@ export class GitIndexer {
     const documents = this.prepareCommitDocuments(commits);
 
     // Phase 3: Store in batches
+    logger?.info(
+      { documents: documents.length, batchSize: this.batchSize },
+      'Starting commit embedding'
+    );
     onProgress?.({
       phase: 'storing',
       commitsProcessed: 0,
@@ -144,26 +158,43 @@ export class GitIndexer {
     });
 
     let commitsIndexed = 0;
+    const totalBatches = Math.ceil(documents.length / this.batchSize);
     for (let i = 0; i < documents.length; i += this.batchSize) {
       const batch = documents.slice(i, i + this.batchSize);
+      const batchNum = Math.floor(i / this.batchSize) + 1;
 
       try {
         await this.vectorStorage.addDocuments(batch);
         commitsIndexed += batch.length;
 
+        // Log every 10 batches
+        if (batchNum % 10 === 0 || batchNum === totalBatches) {
+          logger?.info(
+            { batch: batchNum, totalBatches, commitsIndexed, total: commits.length },
+            `Embedded ${commitsIndexed}/${commits.length} commits`
+          );
+        }
+
         onProgress?.({
           phase: 'storing',
           commitsProcessed: commitsIndexed,
           totalCommits: commits.length,
           percentComplete: 50 + (commitsIndexed / commits.length) * 50,
         });
       } catch (error) {
-        const message = `Failed to store batch ${i / this.batchSize}: ${error instanceof Error ? error.message : String(error)}`;
+        const message = `Failed to store batch ${batchNum}: ${error instanceof Error ? error.message : String(error)}`;
         errors.push(message);
+        logger?.error({ batch: batchNum, error: message }, 'Failed to store commit batch');
       }
     }
 
     // Phase 4: Complete
+    const durationMs = Date.now() - startTime;
+    logger?.info(
+      { commitsIndexed, duration: `${durationMs}ms`, errors: errors.length },
+      'Git indexing complete'
+    );
+
     onProgress?.({
       phase: 'complete',
       commitsProcessed: commitsIndexed,
@@ -173,7 +204,7 @@ export class GitIndexer {
 
     return {
       commitsIndexed,
-      durationMs: Date.now() - startTime,
+      durationMs,
       errors,
     };
   }

packages/subagents/src/github/indexer.ts

@@ -79,16 +79,64 @@ export class GitHubIndexer {
    */
   async index(options: GitHubIndexOptions = {}): Promise<GitHubIndexStats> {
     const startTime = Date.now();
+    const onProgress = options.onProgress;
+    const logger = options.logger?.child({ component: 'github-indexer' });
+
+    logger?.info(
+      { repository: options.repository || this.repository },
+      'Starting GitHub data fetch'
+    );
+
+    // Phase 1: Fetch all documents from GitHub
+    onProgress?.({
+      phase: 'fetching',
+      documentsProcessed: 0,
+      totalDocuments: 0,
+      percentComplete: 0,
+    });
 
-    // Fetch all documents from GitHub
     const documents = fetchAllDocuments({
       ...options,
       repository: options.repository || this.repository,
     });
 
-    // Enrich with relationships
+    logger?.info({ documents: documents.length }, 'Fetched GitHub documents');
+
+    // Phase 2: Enrich with relationships
+    onProgress?.({
+      phase: 'enriching',
+      documentsProcessed: 0,
+      totalDocuments: documents.length,
+      percentComplete: 25,
+    });
+
+    logger?.debug({ documents: documents.length }, 'Enriching documents with relationships');
     const enrichedDocs = documents.map((doc) => enrichDocument(doc));
 
+    // Calculate stats by type
+    const byType = enrichedDocs.reduce(
+      (acc, doc) => {
+        acc[doc.type] = (acc[doc.type] || 0) + 1;
+        return acc;
+      },
+      {} as Record<string, number>
+    );
+
+    logger?.info(
+      { issues: byType.issue || 0, prs: byType.pull_request || 0 },
+      'Document breakdown'
+    );
+
+    // Phase 3: Convert and embed
+    onProgress?.({
+      phase: 'embedding',
+      documentsProcessed: 0,
+      totalDocuments: enrichedDocs.length,
+      percentComplete: 50,
+    });
+
+    logger?.info({ documents: enrichedDocs.length }, 'Starting GitHub embedding');
+
     // Convert to vector storage format
     const vectorDocs = enrichedDocs.map((doc) => ({
       id: `${doc.type}-${doc.number}`,
@@ -114,14 +162,13 @@ export class GitHubIndexer {
     // Duplicates are handled by ID (overwrites existing)
     await this.vectorStorage.addDocuments(vectorDocs);
 
-    // Calculate stats
-    const byType = enrichedDocs.reduce(
-      (acc, doc) => {
-        acc[doc.type] = (acc[doc.type] || 0) + 1;
-        return acc;
-      },
-      {} as Record<string, number>
-    );
+    // Phase 4: Complete
+    onProgress?.({
+      phase: 'complete',
+      documentsProcessed: enrichedDocs.length,
+      totalDocuments: enrichedDocs.length,
+      percentComplete: 100,
+    });
 
     const byState = enrichedDocs.reduce(
       (acc, doc) => {
@@ -144,13 +191,19 @@ export class GitHubIndexer {
     // Save state to disk
     await this.saveState();
 
+    const durationMs = Date.now() - startTime;
+    logger?.info(
+      { documents: enrichedDocs.length, duration: `${durationMs}ms` },
+      'GitHub indexing complete'
+    );
+
     return {
       repository: this.repository,
       totalDocuments: enrichedDocs.length,
       byType: byType as Record<'issue' | 'pull_request' | 'discussion', number>,
       byState: byState as Record<'open' | 'closed' | 'merged', number>,
       lastIndexed: this.state.lastIndexed,
-      indexDuration: Date.now() - startTime,
+      indexDuration: durationMs,
     };
   }
 

packages/subagents/src/github/types.ts

@@ -3,6 +3,8 @@
  * Type definitions for GitHub data indexing and context provision
  */
 
+import type { Logger } from '@lytics/kero';
+
 /**
  * Type of GitHub document
  */
@@ -106,6 +108,16 @@ export interface GitHubIndexerState {
   byState: Record<GitHubState, number>;
 }
 
+/**
+ * Progress information for GitHub indexing
+ */
+export interface GitHubIndexProgress {
+  phase: 'fetching' | 'enriching' | 'embedding' | 'complete';
+  documentsProcessed: number;
+  totalDocuments: number;
+  percentComplete: number;
+}
+
 /**
  * GitHub indexing options
  */
@@ -115,6 +127,10 @@ export interface GitHubIndexOptions {
   state?: GitHubState[];
   since?: string; // ISO date - only index items updated after this
   limit?: number; // Max items to fetch (for testing)
+  /** Progress callback */
+  onProgress?: (progress: GitHubIndexProgress) => void;
+  /** Logger instance */
+  logger?: Logger;
 }
 
 /**