cognitive-core 0.1.0 → 0.2.0

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

@@ -0,0 +1,207 @@
+/**
+ * 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

@@ -0,0 +1,228 @@
+/**
+ * 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));
+}