cognitive-core 0.2.1 → 0.2.2

package/references/sessionlog/src/strategy/common.ts

@@ -1,207 +0,0 @@
-/**
- * Strategy Common Infrastructure
- *
- * Shared utilities used by strategy implementations for metadata branch
- * operations, repository validation, and setup.
- *
- * Ported from Go: strategy/common.go
- */
-
-import {
-  git,
-  gitSafe,
-  refExists,
-  isGitRepository,
-  getWorktreeRoot,
-  getHead,
-  showFile,
-  commitTree,
-  mktree,
-  getGitAuthor,
-} from '../git-operations.js';
-import {
-  CHECKPOINTS_BRANCH,
-  type CheckpointID,
-  type CommittedMetadata,
-  checkpointIDPath,
-} from '../types.js';
-import { ensureGitignore } from '../config.js';
-
-// ============================================================================
-// Repository Validation
-// ============================================================================
-
-/**
- * Validates that the repository is suitable for the manual-commit strategy.
- * Throws if the repository is bare, has no commits, or is not a git repo.
- */
-export async function validateRepository(cwd?: string): Promise<void> {
-  const isRepo = await isGitRepository(cwd);
-  if (!isRepo) {
-    throw new Error('Not a git repository');
-  }
-
-  // Check that it's not a bare repository
-  const isBare = await gitSafe(['rev-parse', '--is-bare-repository'], { cwd });
-  if (isBare?.trim() === 'true') {
-    throw new Error('Cannot operate on a bare repository');
-  }
-
-  // Check that we can access the worktree
-  try {
-    await getWorktreeRoot(cwd);
-  } catch {
-    throw new Error('Failed to access worktree');
-  }
-}
-
-/**
- * Check if the repository has any commits.
- */
-export async function isEmptyRepository(cwd?: string): Promise<boolean> {
-  try {
-    await getHead(cwd);
-    return false;
-  } catch {
-    return true;
-  }
-}
-
-/**
- * Check if commit `ancestor` is an ancestor of commit `descendant`.
- * Uses a bounded traversal to prevent runaway history walks.
- */
-export async function isAncestorOf(
-  ancestor: string,
-  descendant: string,
-  _maxDepth: number = 1000,
-  cwd?: string,
-): Promise<boolean> {
-  const result = await gitSafe(['merge-base', '--is-ancestor', ancestor, descendant], { cwd });
-  // git merge-base --is-ancestor exits 0 if true, 1 if not
-  return result !== null;
-}
-
-/**
- * Check if we're inside a git worktree (not the main repo).
- */
-export async function isInsideWorktree(cwd?: string): Promise<boolean> {
-  const result = await gitSafe(['rev-parse', '--git-common-dir'], { cwd });
-  const gitDir = await gitSafe(['rev-parse', '--git-dir'], { cwd });
-  if (!result || !gitDir) return false;
-  return result.trim() !== gitDir.trim();
-}
-
-// ============================================================================
-// Metadata Branch Operations
-// ============================================================================
-
-/**
- * Ensure the metadata branch (sessionlog/checkpoints/v1) exists.
- * Creates it with an initial empty-tree commit if it doesn't exist.
- */
-export async function ensureMetadataBranch(cwd?: string): Promise<void> {
-  const branchRef = `refs/heads/${CHECKPOINTS_BRANCH}`;
-  const exists = await refExists(branchRef, cwd);
-  if (exists) return;
-
-  // Create an empty tree
-  const emptyTree = await mktree([], cwd);
-  const author = await getGitAuthor(cwd);
-  const commitHash = await commitTree(
-    emptyTree,
-    null,
-    'Initialize Sessionlog checkpoints branch',
-    author,
-    cwd,
-  );
-
-  // Create the branch pointing to this commit
-  await git(['branch', CHECKPOINTS_BRANCH, commitHash], { cwd });
-}
-
-/**
- * Read checkpoint metadata from the metadata branch.
- */
-export async function readCheckpointMetadata(
-  checkpointID: CheckpointID,
-  cwd?: string,
-): Promise<CommittedMetadata | null> {
-  const checkpointPath = checkpointIDPath(checkpointID);
-
-  try {
-    const content = await showFile(CHECKPOINTS_BRANCH, `${checkpointPath}/metadata.json`, cwd);
-    return JSON.parse(content) as CommittedMetadata;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Read a session prompt from the metadata branch tree.
- */
-export async function readSessionPromptFromTree(
-  checkpointID: CheckpointID,
-  sessionIndex: number,
-  cwd?: string,
-): Promise<string> {
-  const checkpointPath = checkpointIDPath(checkpointID);
-
-  try {
-    return await showFile(CHECKPOINTS_BRANCH, `${checkpointPath}/${sessionIndex}/prompt.txt`, cwd);
-  } catch {
-    return '';
-  }
-}
-
-/**
- * Read the agent type from checkpoint metadata.
- */
-export async function readAgentTypeFromTree(
-  checkpointID: CheckpointID,
-  cwd?: string,
-): Promise<string> {
-  const metadata = await readCheckpointMetadata(checkpointID, cwd);
-  return metadata?.agent ?? '';
-}
-
-/**
- * Extract the first user prompt from a transcript or prompt file.
- */
-export function extractFirstPrompt(prompts: string): string {
-  if (!prompts) return '';
-  // Split on the prompt separator
-  const parts = prompts.split('\n---\n');
-  const first = parts[0]?.trim() ?? '';
-  // Truncate to 200 chars
-  return first.length > 200 ? first.slice(0, 200) + '...' : first;
-}
-
-// ============================================================================
-// Setup
-// ============================================================================
-
-/**
- * Full strategy setup: create metadata branch, ensure .gitignore, etc.
- */
-export async function ensureSetup(cwd?: string): Promise<void> {
-  await validateRepository(cwd);
-  await ensureMetadataBranch(cwd);
-  await ensureGitignore(cwd);
-}
-
-/**
- * Get the root directory of the main repository (not a worktree).
- */
-export async function getMainRepoRoot(cwd?: string): Promise<string> {
-  const commonDir = await gitSafe(['rev-parse', '--git-common-dir'], { cwd });
-  if (!commonDir) {
-    throw new Error('Not inside a git repository');
-  }
-
-  const { resolve, dirname } = await import('node:path');
-  // Common dir is typically <repo>/.git or <repo>/.git/worktrees/<name>
-  // For the main repo, --git-common-dir returns .git
-  const absCommon = resolve(cwd ?? process.cwd(), commonDir.trim());
-  return dirname(absCommon);
-}

package/references/sessionlog/src/strategy/content-overlap.ts

@@ -1,228 +0,0 @@
-/**
- * Content Overlap Detection
- *
- * Determines whether a commit contains session-related work by comparing
- * file content (not just filenames) against the shadow branch. This enables
- * accurate detection of the "reverted and replaced" scenario.
- */
-
-import { gitSafe } from '../git-operations.js';
-
-// ============================================================================
-// Content Overlap
-// ============================================================================
-
-/**
- * Check if any file in filesTouched overlaps with the committed content.
- * Uses content-aware comparison to detect the "reverted and replaced" scenario.
- *
- * For modified files (exist in parent), always counts as overlap.
- * For new files, requires content match against shadow branch.
- */
-export async function filesOverlapWithContent(
-  shadowBranchName: string,
-  headCommitHash: string,
-  parentCommitHash: string | null,
-  filesTouched: string[],
-  cwd?: string,
-): Promise<boolean> {
-  if (filesTouched.length === 0) return false;
-
-  for (const filePath of filesTouched) {
-    // Get file from HEAD (committed content)
-    const headContent = await gitSafe(['show', `${headCommitHash}:${filePath}`], { cwd });
-    if (headContent === null) {
-      // File not in HEAD commit - check if it's a deletion
-      if (parentCommitHash) {
-        const parentContent = await gitSafe(['show', `${parentCommitHash}:${filePath}`], { cwd });
-        if (parentContent !== null) {
-          // File existed in parent but not in HEAD = deletion = overlap
-          return true;
-        }
-      }
-      continue;
-    }
-
-    // Check if this is a modified file (exists in parent) or new file
-    let isModified = false;
-    if (parentCommitHash) {
-      const parentContent = await gitSafe(['show', `${parentCommitHash}:${filePath}`], { cwd });
-      isModified = parentContent !== null;
-    }
-
-    // Modified files always count as overlap
-    if (isModified) return true;
-
-    // For new files, check content against shadow branch
-    const shadowContent = await gitSafe(['show', `refs/heads/${shadowBranchName}:${filePath}`], {
-      cwd,
-    });
-    if (shadowContent === null) continue;
-
-    // Compare by hashing - get blob hashes
-    const headHash = await gitSafe(['rev-parse', `${headCommitHash}:${filePath}`], { cwd });
-    const shadowHash = await gitSafe(['rev-parse', `refs/heads/${shadowBranchName}:${filePath}`], {
-      cwd,
-    });
-
-    if (headHash !== null && shadowHash !== null && headHash.trim() === shadowHash.trim()) {
-      return true;
-    }
-
-    // Check for significant content overlap if hashes differ
-    if (headContent && shadowContent && hasSignificantContentOverlap(headContent, shadowContent)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Check if any staged file overlaps with filesTouched using content comparison.
- */
-export async function stagedFilesOverlapWithContent(
-  shadowBranchName: string,
-  stagedFiles: string[],
-  filesTouched: string[],
-  cwd?: string,
-): Promise<boolean> {
-  const touchedSet = new Set(filesTouched);
-
-  for (const stagedPath of stagedFiles) {
-    if (!touchedSet.has(stagedPath)) continue;
-
-    // Check if modified (exists in HEAD) or new
-    const headContent = await gitSafe(['show', `HEAD:${stagedPath}`], { cwd });
-    const isModified = headContent !== null;
-
-    if (isModified) return true;
-
-    // For new files, compare staged content with shadow
-    const shadowContent = await gitSafe(['show', `refs/heads/${shadowBranchName}:${stagedPath}`], {
-      cwd,
-    });
-    if (shadowContent === null) {
-      // File not in shadow branch but is in filesTouched — the agent created it.
-      // The shadow branch only contains HEAD's tree, so new agent-created files
-      // won't be there. Since we've already verified the file is tracked, count it.
-      return true;
-    }
-
-    // Get staged content
-    const stagedContent = await gitSafe(['show', `:${stagedPath}`], { cwd });
-    if (stagedContent === null) continue;
-
-    // Compare hashes
-    const stagedHash = await gitSafe(['rev-parse', `:${stagedPath}`], { cwd });
-    const shadowHash = await gitSafe(
-      ['rev-parse', `refs/heads/${shadowBranchName}:${stagedPath}`],
-      { cwd },
-    );
-
-    if (stagedHash && shadowHash && stagedHash.trim() === shadowHash.trim()) {
-      return true;
-    }
-
-    // Check significant overlap
-    if (hasSignificantContentOverlap(stagedContent, shadowContent)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Return files from filesTouched that still have uncommitted agent changes.
- */
-export async function filesWithRemainingAgentChanges(
-  shadowBranchName: string,
-  headCommitHash: string,
-  filesTouched: string[],
-  committedFiles: Set<string>,
-  cwd?: string,
-): Promise<string[]> {
-  const remaining: string[] = [];
-
-  for (const filePath of filesTouched) {
-    if (!committedFiles.has(filePath)) {
-      remaining.push(filePath);
-      continue;
-    }
-
-    // File was committed - check if committed content matches shadow
-    const commitHash = await gitSafe(['rev-parse', `${headCommitHash}:${filePath}`], { cwd });
-    const shadowHash = await gitSafe(['rev-parse', `refs/heads/${shadowBranchName}:${filePath}`], {
-      cwd,
-    });
-
-    if (commitHash === null || shadowHash === null) continue;
-    if (commitHash.trim() === shadowHash.trim()) continue;
-
-    // Content differs - check if working tree is clean for this file
-    const workingDiff = await gitSafe(['diff', '--name-only', 'HEAD', '--', filePath], { cwd });
-    if (workingDiff !== null && workingDiff.trim() === '') {
-      // Working tree is clean - user intentionally wrote different content
-      continue;
-    }
-
-    remaining.push(filePath);
-  }
-
-  return remaining;
-}
-
-// ============================================================================
-// Content Overlap Helpers
-// ============================================================================
-
-/**
- * Check if two file contents share significant lines.
- * Distinguishes partial staging from "reverted and replaced".
- */
-export function hasSignificantContentOverlap(
-  stagedContent: string,
-  shadowContent: string,
-): boolean {
-  const shadowLines = extractSignificantLines(shadowContent);
-  const stagedLines = extractSignificantLines(stagedContent);
-
-  if (shadowLines.size === 0 || stagedLines.size === 0) return false;
-
-  const isVerySmallFile = shadowLines.size < 2 || stagedLines.size < 2;
-  const requiredMatches = isVerySmallFile ? 1 : 2;
-
-  let matchCount = 0;
-  for (const line of stagedLines) {
-    if (shadowLines.has(line)) {
-      matchCount++;
-      if (matchCount >= requiredMatches) return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Extract significant lines from content (>= 10 chars after trimming).
- * Short lines like `{`, `}`, `});` are filtered as common boilerplate.
- */
-function extractSignificantLines(content: string): Set<string> {
-  const lines = new Set<string>();
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim();
-    if (trimmed.length >= 10) {
-      lines.add(trimmed);
-    }
-  }
-  return lines;
-}
-
-/**
- * Simple filename-based overlap check (fallback).
- */
-export function hasOverlappingFiles(stagedFiles: string[], filesTouched: string[]): boolean {
-  const touchedSet = new Set(filesTouched);
-  return stagedFiles.some((f) => touchedSet.has(f));
-}