feat: add knowledge-silo command to detect team knowledge silos

Analyzes git history per directory to identify areas where only one or
two people have contributed. Computes silo scores using commit
concentration metrics, ranks directories by risk, and outputs a
markdown report with recommendations for knowledge transfer.

Nightshift-Task: knowledge-silo
Nightshift-Ref: https://github.com/marcus/nightshift

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: marcus

cmd/nightshift/commands/silo.go

@@ -0,0 +1,165 @@
+package commands
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/marcus/nightshift/internal/analysis"
+	"github.com/marcus/nightshift/internal/config"
+	"github.com/marcus/nightshift/internal/db"
+	"github.com/marcus/nightshift/internal/logging"
+)
+
+var knowledgeSiloCmd = &cobra.Command{
+	Use:   "knowledge-silo [path]",
+	Short: "Detect knowledge silos in a repository",
+	Long: `Analyze git history per directory to identify knowledge silos —
+areas of code where only one or two people have contributed.
+
+Each directory is scored by contributor concentration. Directories where a
+single person owns most of the commits are flagged as knowledge silos,
+ranked by severity.
+
+Metrics:
+  - Silo Score: 0-1 concentration score (1 = complete silo)
+  - Risk Level: critical/high/medium/low per directory
+  - Top Contributors: dominant author(s) per directory`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		path, err := cmd.Flags().GetString("path")
+		if err != nil {
+			return err
+		}
+
+		if path == "" && len(args) > 0 {
+			path = args[0]
+		}
+		if path == "" {
+			var err error
+			path, err = os.Getwd()
+			if err != nil {
+				return fmt.Errorf("getting current directory: %w", err)
+			}
+		}
+
+		jsonOutput, _ := cmd.Flags().GetBool("json")
+		since, _ := cmd.Flags().GetString("since")
+		until, _ := cmd.Flags().GetString("until")
+		depth, _ := cmd.Flags().GetInt("depth")
+		minCommits, _ := cmd.Flags().GetInt("min-commits")
+		saveReport, _ := cmd.Flags().GetBool("save")
+		dbPath, _ := cmd.Flags().GetString("db")
+
+		return runKnowledgeSilo(path, jsonOutput, since, until, depth, minCommits, saveReport, dbPath)
+	},
+}
+
+func init() {
+	knowledgeSiloCmd.Flags().StringP("path", "p", "", "Repository path")
+	knowledgeSiloCmd.Flags().Bool("json", false, "Output as JSON")
+	knowledgeSiloCmd.Flags().String("since", "", "Start date (RFC3339 or YYYY-MM-DD)")
+	knowledgeSiloCmd.Flags().String("until", "", "End date (RFC3339 or YYYY-MM-DD)")
+	knowledgeSiloCmd.Flags().Int("depth", 2, "Directory depth for grouping")
+	knowledgeSiloCmd.Flags().Int("min-commits", 5, "Minimum commits to include a directory")
+	knowledgeSiloCmd.Flags().Bool("save", false, "Save results to database")
+	knowledgeSiloCmd.Flags().String("db", "", "Database path (uses config if not set)")
+	rootCmd.AddCommand(knowledgeSiloCmd)
+}
+
+func runKnowledgeSilo(path string, jsonOutput bool, since, until string, depth, minCommits int, saveReport bool, dbPath string) error {
+	logger := logging.Component("knowledge-silo")
+
+	absPath, err := filepath.Abs(path)
+	if err != nil {
+		return fmt.Errorf("resolving path: %w", err)
+	}
+
+	if !analysis.RepositoryExists(absPath) {
+		return fmt.Errorf("not a git repository: %s", absPath)
+	}
+
+	var sinceTime, untilTime time.Time
+	if since != "" {
+		t, err := parseDate(since)
+		if err != nil {
+			return fmt.Errorf("parsing since date: %w", err)
+		}
+		sinceTime = t
+	}
+	if until != "" {
+		t, err := parseDate(until)
+		if err != nil {
+			return fmt.Errorf("parsing until date: %w", err)
+		}
+		untilTime = t
+	}
+
+	parser := analysis.NewGitParser(absPath)
+	opts := analysis.ParseOptions{
+		Since: sinceTime,
+		Until: untilTime,
+	}
+
+	dirAuthors, err := parser.ParseAuthorsByDirectory(opts, depth)
+	if err != nil {
+		return fmt.Errorf("parsing git history: %w", err)
+	}
+
+	if len(dirAuthors) == 0 {
+		logger.Warnf("no commits found in %s", absPath)
+		return nil
+	}
+
+	entries := analysis.CalculateSilos(dirAuthors, minCommits)
+
+	gen := analysis.NewSiloReportGenerator()
+	report := gen.Generate(absPath, depth, entries)
+
+	if jsonOutput {
+		enc := json.NewEncoder(os.Stdout)
+		enc.SetIndent("", "  ")
+		return enc.Encode(report)
+	}
+
+	markdown := gen.RenderMarkdown(report)
+	fmt.Println(markdown)
+
+	if saveReport {
+		if dbPath == "" {
+			cfg, err := config.Load()
+			if err != nil {
+				logger.Warnf("could not load config for db path: %v", err)
+			} else {
+				dbPath = cfg.ExpandedDBPath()
+			}
+		}
+
+		if dbPath != "" {
+			database, err := db.Open(dbPath)
+			if err != nil {
+				logger.Errorf("opening database: %v", err)
+			} else {
+				defer func() { _ = database.Close() }()
+
+				result := &analysis.SiloResult{
+					Timestamp: time.Now(),
+					RepoPath:  absPath,
+					Depth:     depth,
+					Results:   report,
+				}
+
+				if err := result.Store(database.SQL()); err != nil {
+					logger.Errorf("storing result: %v", err)
+				} else {
+					logger.Infof("results saved (ID: %d)", result.ID)
+				}
+			}
+		}
+	}
+
+	return nil
+}

internal/analysis/silo.go

@@ -0,0 +1,227 @@
+package analysis
+
+import (
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// SiloEntry represents a single directory's knowledge silo metrics.
+type SiloEntry struct {
+	Directory    string         `json:"directory"`
+	TopAuthors   []CommitAuthor `json:"top_authors"`
+	TotalCommits int            `json:"total_commits"`
+	Contributors int            `json:"contributors"`
+	SiloScore    float64        `json:"silo_score"` // 0-1, 1 = max silo risk
+	RiskLevel    string         `json:"risk_level"` // critical, high, medium, low
+}
+
+// SiloReport holds the full silo analysis results.
+type SiloReport struct {
+	Entries       []SiloEntry `json:"entries"`
+	TotalDirs     int         `json:"total_dirs"`
+	CriticalSilos int         `json:"critical_silos"`
+	HighSilos     int         `json:"high_silos"`
+	MediumSilos   int         `json:"medium_silos"`
+	LowSilos      int         `json:"low_silos"`
+	OverallRisk   string      `json:"overall_risk"`
+	RepoPath      string      `json:"repo_path"`
+	Depth         int         `json:"depth"`
+}
+
+// ParseAuthorsByDirectory runs git log to build a map of directory -> []CommitAuthor
+// at the given depth level.
+func (gp *GitParser) ParseAuthorsByDirectory(opts ParseOptions, depth int) (map[string][]CommitAuthor, error) {
+	args := []string{"log", "--format=COMMIT:%an|%ae", "--name-only"}
+
+	if !opts.Since.IsZero() {
+		args = append(args, fmt.Sprintf("--since=%s", opts.Since.Format("2006-01-02T15:04:05Z07:00")))
+	}
+	if !opts.Until.IsZero() {
+		args = append(args, fmt.Sprintf("--until=%s", opts.Until.Format("2006-01-02T15:04:05Z07:00")))
+	}
+
+	cmd := exec.Command("git", args...)
+	cmd.Dir = gp.repoPath
+
+	output, err := cmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("running git log: %w", err)
+	}
+
+	// Parse output: lines alternate between COMMIT:author|email and file paths
+	// Each commit block starts with COMMIT: line followed by file paths
+	dirAuthors := make(map[string]map[string]*CommitAuthor) // dir -> email -> author
+	var currentName, currentEmail string
+
+	for line := range strings.SplitSeq(string(output), "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+
+		if after, ok := strings.CutPrefix(line, "COMMIT:"); ok {
+			parts := strings.SplitN(after, "|", 2)
+			if len(parts) == 2 {
+				currentName = parts[0]
+				currentEmail = parts[1]
+			}
+			continue
+		}
+
+		// This is a file path — extract directory at the configured depth
+		if currentEmail == "" {
+			continue
+		}
+
+		dir := truncateDir(line, depth)
+		if dir == "" {
+			continue
+		}
+
+		if dirAuthors[dir] == nil {
+			dirAuthors[dir] = make(map[string]*CommitAuthor)
+		}
+
+		key := strings.ToLower(currentEmail)
+		if author, exists := dirAuthors[dir][key]; exists {
+			author.Commits++
+		} else {
+			dirAuthors[dir][key] = &CommitAuthor{
+				Name:    currentName,
+				Email:   currentEmail,
+				Commits: 1,
+			}
+		}
+	}
+
+	// Convert to map[string][]CommitAuthor
+	result := make(map[string][]CommitAuthor, len(dirAuthors))
+	for dir, authorMap := range dirAuthors {
+		authors := make([]CommitAuthor, 0, len(authorMap))
+		for _, a := range authorMap {
+			authors = append(authors, *a)
+		}
+		// Sort by commits descending
+		sort.Slice(authors, func(i, j int) bool {
+			return authors[i].Commits > authors[j].Commits
+		})
+		result[dir] = authors
+	}
+
+	return result, nil
+}
+
+// truncateDir extracts the directory path truncated to the given depth.
+// For depth=2, "internal/analysis/silo.go" -> "internal/analysis"
+func truncateDir(filePath string, depth int) string {
+	dir := filepath.Dir(filePath)
+	if dir == "." {
+		return "."
+	}
+
+	parts := strings.Split(filepath.ToSlash(dir), "/")
+	if len(parts) > depth {
+		parts = parts[:depth]
+	}
+
+	return strings.Join(parts, "/")
+}
+
+// CalculateSilos computes silo metrics for each directory.
+// minCommits filters out directories with fewer commits than the threshold.
+func CalculateSilos(dirAuthors map[string][]CommitAuthor, minCommits int) []SiloEntry {
+	var entries []SiloEntry
+
+	for dir, authors := range dirAuthors {
+		totalCommits := 0
+		for _, a := range authors {
+			totalCommits += a.Commits
+		}
+
+		if totalCommits < minCommits {
+			continue
+		}
+
+		score := calculateSiloScore(authors, totalCommits)
+		risk := assessSiloRisk(authors, totalCommits, score)
+
+		// Keep top 3 authors max
+		topAuthors := authors
+		if len(topAuthors) > 3 {
+			topAuthors = topAuthors[:3]
+		}
+
+		entries = append(entries, SiloEntry{
+			Directory:    dir,
+			TopAuthors:   topAuthors,
+			TotalCommits: totalCommits,
+			Contributors: len(authors),
+			SiloScore:    score,
+			RiskLevel:    risk,
+		})
+	}
+
+	// Sort by silo score descending (worst silos first)
+	sort.Slice(entries, func(i, j int) bool {
+		return entries[i].SiloScore > entries[j].SiloScore
+	})
+
+	return entries
+}
+
+// calculateSiloScore computes a 0-1 score where 1 = complete knowledge silo.
+// Uses inverse normalized contributor count weighted by commit concentration.
+func calculateSiloScore(authors []CommitAuthor, totalCommits int) float64 {
+	if len(authors) == 0 || totalCommits == 0 {
+		return 0
+	}
+
+	if len(authors) == 1 {
+		return 1.0
+	}
+
+	// Herfindahl-style concentration
+	hhi := 0.0
+	for _, a := range authors {
+		share := float64(a.Commits) / float64(totalCommits)
+		hhi += share * share
+	}
+
+	// Top contributor share
+	topShare := float64(authors[0].Commits) / float64(totalCommits)
+
+	// Combine: weight HHI (concentration) and top-contributor dominance
+	// Both range 0-1; average gives balanced silo score
+	score := (hhi + topShare) / 2.0
+
+	return score
+}
+
+// assessSiloRisk classifies a directory's silo risk level.
+func assessSiloRisk(authors []CommitAuthor, totalCommits int, siloScore float64) string {
+	if len(authors) == 0 || totalCommits == 0 {
+		return "low"
+	}
+
+	topShare := float64(authors[0].Commits) / float64(totalCommits)
+
+	// Critical: single contributor or top contributor >80%
+	if len(authors) <= 1 || topShare > 0.80 {
+		return "critical"
+	}
+
+	// High: top contributor >60% or only 2 contributors
+	if topShare > 0.60 || len(authors) <= 2 {
+		return "high"
+	}
+
+	// Medium: silo score > 0.4 or 3 contributors
+	if siloScore > 0.4 || len(authors) <= 3 {
+		return "medium"
+	}
+
+	return "low"
+}