claude-code-swarm 0.3.2 → 0.3.4

package/references/opentasks/src/entire/agent/session-types.ts

@@ -1,117 +0,0 @@
-/**
- * Normalized Agent Session Type
- *
- * A shared, agent-agnostic representation of a coding session with typed
- * entries. This provides a uniform interface for cross-agent operations.
- *
- * Ported from Go: agent/session.go
- */
-
-import type { AgentType, TokenUsage } from '../types.js';
-
-// ============================================================================
-// Entry Types
-// ============================================================================
-
-export const enum EntryType {
-  User = 'user',
-  Assistant = 'assistant',
-  Tool = 'tool',
-  System = 'system',
-}
-
-export interface SessionEntry {
-  type: EntryType;
-  uuid?: string;
-  timestamp?: string;
-  text?: string;
-  toolName?: string;
-  toolInput?: unknown;
-  toolResult?: unknown;
-}
-
-// ============================================================================
-// Agent Session
-// ============================================================================
-
-export interface AgentSession {
-  readonly agentType: AgentType;
-  readonly sessionID: string;
-  readonly entries: SessionEntry[];
-
-  /** Get the last user prompt text */
-  getLastUserPrompt(): string;
-
-  /** Get all user prompts */
-  getUserPrompts(): string[];
-
-  /** Get the total number of entries */
-  length(): number;
-
-  /** Truncate the session at a specific UUID (for partial replay) */
-  truncateAtUUID(uuid: string): AgentSession;
-
-  /** Find the tool result entry for a given tool use UUID */
-  findToolResultByUUID(uuid: string): SessionEntry | undefined;
-
-  /** Get all entries of a specific type */
-  getEntriesByType(type: EntryType): SessionEntry[];
-
-  /** Get entries from a specific offset */
-  slice(fromOffset: number): SessionEntry[];
-}
-
-// ============================================================================
-// Implementation
-// ============================================================================
-
-export function createAgentSession(
-  agentType: AgentType,
-  sessionID: string,
-  entries: SessionEntry[],
-): AgentSession {
-  return {
-    agentType,
-    sessionID,
-    entries,
-
-    getLastUserPrompt(): string {
-      for (let i = entries.length - 1; i >= 0; i--) {
-        if (entries[i].type === EntryType.User && entries[i].text) {
-          return entries[i].text!;
-        }
-      }
-      return '';
-    },
-
-    getUserPrompts(): string[] {
-      return entries
-        .filter(e => e.type === EntryType.User && e.text)
-        .map(e => e.text!);
-    },
-
-    length(): number {
-      return entries.length;
-    },
-
-    truncateAtUUID(uuid: string): AgentSession {
-      const idx = entries.findIndex(e => e.uuid === uuid);
-      if (idx === -1) return createAgentSession(agentType, sessionID, entries);
-      return createAgentSession(agentType, sessionID, entries.slice(0, idx + 1));
-    },
-
-    findToolResultByUUID(uuid: string): SessionEntry | undefined {
-      return entries.find(
-        e => e.type === EntryType.Tool && e.uuid === uuid,
-      );
-    },
-
-    getEntriesByType(type: EntryType): SessionEntry[] {
-      return entries.filter(e => e.type === type);
-    },
-
-    slice(fromOffset: number): SessionEntry[] {
-      return entries.slice(fromOffset);
-    },
-  };
-}

package/references/opentasks/src/entire/agent/types.ts

@@ -1,217 +0,0 @@
-/**
- * Agent Types
- *
- * Interfaces for AI agent integrations. Each supported agent
- * (Claude Code, Cursor, Gemini CLI, OpenCode) implements these
- * interfaces to participate in the Entire session tracking lifecycle.
- */
-
-import type { AgentName, AgentType, HookInput, Event, SessionState, TokenUsage } from '../types.js';
-
-// ============================================================================
-// Core Agent Interface
-// ============================================================================
-
-/**
- * Agent represents a supported AI coding agent
- */
-export interface Agent {
-  /** Registry key (e.g., 'claude-code') */
-  readonly name: AgentName;
-
-  /** Human-readable type (e.g., 'Claude Code') */
-  readonly type: AgentType;
-
-  /** Description of the agent */
-  readonly description: string;
-
-  /** Whether this agent integration is in preview */
-  readonly isPreview: boolean;
-
-  /** Directories that should never be modified/deleted by Entire */
-  readonly protectedDirs: string[];
-
-  /** Check if this agent is present in the current environment */
-  detectPresence(cwd?: string): Promise<boolean>;
-
-  /** Get the session directory for this agent */
-  getSessionDir(repoPath: string): Promise<string>;
-
-  /** Get session ID from hook input */
-  getSessionID(input: HookInput): string;
-
-  /** Resolve transcript file path */
-  resolveSessionFile(sessionDir: string, agentSessionID: string): string;
-
-  /** Read the raw transcript for a session */
-  readTranscript(sessionRef: string): Promise<Buffer>;
-
-  /** Format a resume command for the user */
-  formatResumeCommand(sessionID: string): string;
-}
-
-// ============================================================================
-// Optional Agent Capabilities
-// ============================================================================
-
-/**
- * Agent supports lifecycle hooks
- */
-export interface HookSupport {
-  /** Hook names this agent supports */
-  hookNames(): string[];
-
-  /** Parse a hook event from stdin */
-  parseHookEvent(hookName: string, stdin: string): Event | null;
-
-  /** Install hooks for this agent in a repo */
-  installHooks(repoPath: string, force?: boolean): Promise<number>;
-
-  /** Remove hooks for this agent from a repo */
-  uninstallHooks(repoPath: string): Promise<void>;
-
-  /** Check if hooks are installed */
-  areHooksInstalled(repoPath: string): Promise<boolean>;
-}
-
-/**
- * Agent supports file watching for session changes
- */
-export interface FileWatcher {
-  /** Get paths to watch for changes */
-  getWatchPaths(repoPath: string): Promise<string[]>;
-
-  /** Handle a file change event */
-  onFileChange(filePath: string): Promise<SessionChangeEvent | null>;
-}
-
-/**
- * Agent supports transcript analysis
- */
-export interface TranscriptAnalyzer {
-  /** Get current position in the transcript */
-  getTranscriptPosition(transcriptPath: string): Promise<number>;
-
-  /** Extract modified files from a transcript segment */
-  extractModifiedFilesFromOffset(
-    transcriptPath: string,
-    startOffset: number,
-  ): Promise<{ files: string[]; currentPosition: number }>;
-
-  /** Extract user prompts from a transcript segment */
-  extractPrompts(sessionRef: string, fromOffset: number): Promise<string[]>;
-
-  /** Extract a summary from the transcript */
-  extractSummary(sessionRef: string): Promise<string>;
-}
-
-/**
- * Agent supports token usage calculation
- */
-export interface TokenCalculator {
-  /** Calculate token usage from a transcript segment */
-  calculateTokenUsage(transcriptData: Buffer, fromOffset: number): Promise<TokenUsage>;
-}
-
-/**
- * Agent supports transcript preparation (e.g., waiting for async flush).
- *
- * Some agents write transcripts asynchronously. Before reading the transcript
- * for checkpoint creation, the agent can wait for a flush sentinel to ensure
- * the transcript is complete.
- */
-export interface TranscriptPreparer {
-  /** Wait for the transcript to be fully flushed before reading */
-  prepareTranscript(sessionRef: string): Promise<void>;
-}
-
-/**
- * Agent supports subagent-aware extraction (e.g., Claude Code's Task tool).
- * Aggregates files and tokens from both the main session and spawned subagents.
- */
-export interface SubagentAwareExtractor {
-  /** Extract files modified by both the main agent and any spawned subagents */
-  extractAllModifiedFiles(
-    transcriptData: Buffer,
-    fromOffset: number,
-    subagentsDir: string,
-  ): Promise<string[]>;
-
-  /** Calculate token usage including all spawned subagents */
-  calculateTotalTokenUsage(
-    transcriptData: Buffer,
-    fromOffset: number,
-    subagentsDir: string,
-  ): Promise<TokenUsage>;
-}
-
-/**
- * Agent supports transcript chunking for storage
- */
-export interface TranscriptChunker {
-  /** Split a transcript into storage-safe chunks */
-  chunkTranscript(content: Buffer, maxSize: number): Promise<Buffer[]>;
-
-  /** Reassemble chunked transcripts */
-  reassembleTranscript(chunks: Buffer[]): Promise<Buffer>;
-}
-
-// ============================================================================
-// Session Change Event (from FileWatcher)
-// ============================================================================
-
-export interface SessionChangeEvent {
-  sessionID: string;
-  sessionRef: string;
-  eventType: string;
-  timestamp: Date;
-}
-
-// ============================================================================
-// Type Guards
-// ============================================================================
-
-export function hasHookSupport(agent: Agent): agent is Agent & HookSupport {
-  return 'hookNames' in agent && typeof (agent as unknown as HookSupport).hookNames === 'function';
-}
-
-export function hasFileWatcher(agent: Agent): agent is Agent & FileWatcher {
-  return 'getWatchPaths' in agent && typeof (agent as unknown as FileWatcher).getWatchPaths === 'function';
-}
-
-export function hasTranscriptAnalyzer(agent: Agent): agent is Agent & TranscriptAnalyzer {
-  return (
-    'getTranscriptPosition' in agent &&
-    typeof (agent as unknown as TranscriptAnalyzer).getTranscriptPosition === 'function'
-  );
-}
-
-export function hasTokenCalculator(agent: Agent): agent is Agent & TokenCalculator {
-  return (
-    'calculateTokenUsage' in agent &&
-    typeof (agent as unknown as TokenCalculator).calculateTokenUsage === 'function'
-  );
-}
-
-export function hasTranscriptPreparer(agent: Agent): agent is Agent & TranscriptPreparer {
-  return (
-    'prepareTranscript' in agent &&
-    typeof (agent as unknown as TranscriptPreparer).prepareTranscript === 'function'
-  );
-}
-
-export function hasSubagentAwareExtractor(agent: Agent): agent is Agent & SubagentAwareExtractor {
-  return (
-    'extractAllModifiedFiles' in agent &&
-    typeof (agent as unknown as SubagentAwareExtractor).extractAllModifiedFiles === 'function' &&
-    'calculateTotalTokenUsage' in agent &&
-    typeof (agent as unknown as SubagentAwareExtractor).calculateTotalTokenUsage === 'function'
-  );
-}
-
-export function hasTranscriptChunker(agent: Agent): agent is Agent & TranscriptChunker {
-  return (
-    'chunkTranscript' in agent &&
-    typeof (agent as unknown as TranscriptChunker).chunkTranscript === 'function'
-  );
-}

package/references/opentasks/src/entire/commands/clean.ts

@@ -1,134 +0,0 @@
-/**
- * Clean Command
- *
- * Removes orphaned Entire data: shadow branches, stale session files,
- * and temporary files that are no longer referenced.
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { ENTIRE_TMP_DIR, SHADOW_BRANCH_PREFIX, CHECKPOINTS_BRANCH, SESSION_DIR_NAME } from '../types.js';
-import { getWorktreeRoot, getGitDir, listBranches, deleteBranch } from '../git-operations.js';
-import { createSessionStore } from '../store/session-store.js';
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface CleanupItem {
-  type: 'shadow-branch' | 'session-file' | 'temp-file';
-  path: string;
-  reason: string;
-}
-
-export interface CleanResult {
-  items: CleanupItem[];
-  deletedCount: number;
-  errors: string[];
-}
-
-export interface CleanOptions {
-  cwd?: string;
-  /** Actually delete (default: preview only) */
-  force?: boolean;
-}
-
-// ============================================================================
-// Implementation
-// ============================================================================
-
-/**
- * Find orphaned items
- */
-export async function findOrphaned(cwd?: string): Promise<CleanupItem[]> {
-  const items: CleanupItem[] = [];
-  const sessionStore = createSessionStore(cwd);
-  const sessions = await sessionStore.list();
-  const activeSessionIDs = new Set(sessions.map((s) => s.sessionID));
-  const activeBaseCommits = new Set(sessions.map((s) => s.baseCommit).filter(Boolean));
-
-  // 1. Orphaned shadow branches
-  const branches = await listBranches(`${SHADOW_BRANCH_PREFIX}*`, cwd);
-  for (const branch of branches) {
-    if (branch === CHECKPOINTS_BRANCH) continue;
-
-    // Extract base commit from branch name
-    const hashPart = branch.slice(SHADOW_BRANCH_PREFIX.length);
-    const baseCommit = hashPart.split('-')[0];
-
-    // A shadow branch is orphaned if no active session references its base commit
-    if (!activeBaseCommits.has(baseCommit)) {
-      // Check against full base commits (the hash part is a short hash)
-      const isReferenced = sessions.some(
-        (s) => s.baseCommit && s.baseCommit.startsWith(baseCommit),
-      );
-
-      if (!isReferenced) {
-        items.push({
-          type: 'shadow-branch',
-          path: branch,
-          reason: 'No active session references this branch',
-        });
-      }
-    }
-  }
-
-  // 2. Orphaned temp files
-  try {
-    const root = await getWorktreeRoot(cwd);
-    const tmpDir = path.join(root, ENTIRE_TMP_DIR);
-
-    const files = await fs.promises.readdir(tmpDir).catch(() => []);
-    for (const file of files) {
-      const filePath = path.join(tmpDir, file);
-      const stat = await fs.promises.stat(filePath);
-
-      // Consider temp files older than 24 hours as orphaned
-      if (Date.now() - stat.mtimeMs > 24 * 60 * 60 * 1000) {
-        items.push({
-          type: 'temp-file',
-          path: filePath,
-          reason: 'Temporary file older than 24 hours',
-        });
-      }
-    }
-  } catch {
-    // Temp dir may not exist
-  }
-
-  return items;
-}
-
-/**
- * Clean orphaned items
- */
-export async function clean(options: CleanOptions = {}): Promise<CleanResult> {
-  const cwd = options.cwd;
-  const items = await findOrphaned(cwd);
-  const errors: string[] = [];
-  let deletedCount = 0;
-
-  if (!options.force) {
-    return { items, deletedCount: 0, errors: [] };
-  }
-
-  for (const item of items) {
-    try {
-      switch (item.type) {
-        case 'shadow-branch':
-          await deleteBranch(item.path, true, cwd);
-          deletedCount++;
-          break;
-        case 'session-file':
-        case 'temp-file':
-          await fs.promises.unlink(item.path);
-          deletedCount++;
-          break;
-      }
-    } catch (e) {
-      errors.push(`Failed to delete ${item.path}: ${e instanceof Error ? e.message : String(e)}`);
-    }
-  }
-
-  return { items, deletedCount, errors };
-}

package/references/opentasks/src/entire/commands/disable.ts

@@ -1,85 +0,0 @@
-/**
- * Disable Command
- *
- * Disables Entire in a repository. Can optionally fully uninstall
- * hooks and clean up all Entire data.
- */
-
-import { type AgentName, ENTIRE_DIR } from '../types.js';
-import { getWorktreeRoot, isGitRepository } from '../git-operations.js';
-import { saveProjectSettings, saveLocalSettings } from '../config.js';
-import { uninstallGitHooks } from '../hooks/git-hooks.js';
-import { getAgent, listAgentNames, detectAgents } from '../agent/registry.js';
-import { hasHookSupport } from '../agent/types.js';
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface DisableOptions {
-  cwd?: string;
-  /** Fully uninstall hooks (not just disable) */
-  uninstall?: boolean;
-  /** Disable in local settings instead of project settings */
-  local?: boolean;
-}
-
-export interface DisableResult {
-  disabled: boolean;
-  uninstalled: boolean;
-  errors: string[];
-}
-
-// ============================================================================
-// Implementation
-// ============================================================================
-
-/**
- * Disable Entire in a repository
- */
-export async function disable(options: DisableOptions = {}): Promise<DisableResult> {
-  const cwd = options.cwd ?? process.cwd();
-  const errors: string[] = [];
-
-  if (!(await isGitRepository(cwd))) {
-    return { disabled: false, uninstalled: false, errors: ['Not a git repository'] };
-  }
-
-  const root = await getWorktreeRoot(cwd);
-
-  // Update settings
-  if (options.local) {
-    await saveLocalSettings({ enabled: false }, cwd);
-  } else {
-    await saveProjectSettings({ enabled: false }, cwd);
-  }
-
-  let uninstalled = false;
-
-  if (options.uninstall) {
-    // Remove git hooks
-    try {
-      await uninstallGitHooks(root);
-    } catch (e) {
-      errors.push(`Failed to uninstall git hooks: ${e instanceof Error ? e.message : String(e)}`);
-    }
-
-    // Remove agent hooks
-    const agents = await detectAgents(cwd);
-    for (const agent of agents) {
-      if (hasHookSupport(agent)) {
-        try {
-          await agent.uninstallHooks(root);
-        } catch (e) {
-          errors.push(
-            `Failed to uninstall ${agent.name} hooks: ${e instanceof Error ? e.message : String(e)}`,
-          );
-        }
-      }
-    }
-
-    uninstalled = true;
-  }
-
-  return { disabled: true, uninstalled, errors };
-}

package/references/opentasks/src/entire/commands/doctor.ts

@@ -1,152 +0,0 @@
-/**
- * Doctor Command
- *
- * Identifies and fixes stuck sessions. A session is "stuck" if it's
- * in ACTIVE phase with no recent interaction, or in ENDED phase with
- * uncondensed checkpoint data.
- */
-
-import type { SessionState } from '../types.js';
-import { createSessionStore, type SessionStore } from '../store/session-store.js';
-import { createCheckpointStore, type CheckpointStore } from '../store/checkpoint-store.js';
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface StuckSession {
-  sessionID: string;
-  reason: 'active-stale' | 'ended-uncondensed';
-  session: SessionState;
-  hasShadowBranch: boolean;
-  canCondense: boolean;
-}
-
-export interface DoctorResult {
-  stuckSessions: StuckSession[];
-  fixedCount: number;
-  discardedCount: number;
-  errors: string[];
-}
-
-export interface DoctorOptions {
-  cwd?: string;
-  /** Auto-fix without prompting */
-  force?: boolean;
-  /** Stale threshold in milliseconds (default: 1 hour) */
-  staleThresholdMs?: number;
-}
-
-// ============================================================================
-// Implementation
-// ============================================================================
-
-/**
- * Diagnose stuck sessions
- */
-export async function diagnose(options: DoctorOptions = {}): Promise<StuckSession[]> {
-  const cwd = options.cwd;
-  const staleThreshold = options.staleThresholdMs ?? 60 * 60 * 1000; // 1 hour
-
-  const sessionStore = createSessionStore(cwd);
-  const checkpointStore = createCheckpointStore(cwd);
-
-  const sessions = await sessionStore.list();
-  const temporaryBranches = await checkpointStore.listTemporary();
-  const stuck: StuckSession[] = [];
-
-  for (const session of sessions) {
-    // Check for active stale sessions
-    if (session.phase === 'active') {
-      const lastInteraction = session.lastInteractionTime
-        ? new Date(session.lastInteractionTime).getTime()
-        : new Date(session.startedAt).getTime();
-
-      if (Date.now() - lastInteraction > staleThreshold) {
-        const hasShadow = temporaryBranches.some(
-          (b) => b.sessionID === session.sessionID,
-        );
-
-        stuck.push({
-          sessionID: session.sessionID,
-          reason: 'active-stale',
-          session,
-          hasShadowBranch: hasShadow,
-          canCondense: hasShadow && session.filesTouched.length > 0,
-        });
-      }
-    }
-
-    // Check for ended sessions with uncondensed data
-    if (session.phase === 'ended') {
-      const hasShadow = temporaryBranches.some(
-        (b) => b.sessionID === session.sessionID,
-      );
-
-      if (hasShadow) {
-        stuck.push({
-          sessionID: session.sessionID,
-          reason: 'ended-uncondensed',
-          session,
-          hasShadowBranch: true,
-          canCondense: session.filesTouched.length > 0,
-        });
-      }
-    }
-  }
-
-  return stuck;
-}
-
-/**
- * Discard a stuck session (delete state + shadow branch)
- */
-export async function discardSession(
-  sessionID: string,
-  options: { cwd?: string } = {},
-): Promise<void> {
-  const cwd = options.cwd;
-  const sessionStore = createSessionStore(cwd);
-  const checkpointStore = createCheckpointStore(cwd);
-
-  const session = await sessionStore.load(sessionID);
-  if (!session) return;
-
-  // Delete shadow branch if it exists
-  if (session.baseCommit) {
-    const branchName = checkpointStore.getShadowBranchName(
-      session.baseCommit,
-      session.worktreeID,
-    );
-    await checkpointStore.deleteShadowBranch(branchName);
-  }
-
-  // Delete session state
-  await sessionStore.delete(sessionID);
-}
-
-/**
- * Run doctor with auto-fix
- */
-export async function doctor(options: DoctorOptions = {}): Promise<DoctorResult> {
-  const stuck = await diagnose(options);
-  const errors: string[] = [];
-  let fixedCount = 0;
-  let discardedCount = 0;
-
-  if (options.force) {
-    for (const s of stuck) {
-      try {
-        // For now, discard all stuck sessions
-        await discardSession(s.sessionID, { cwd: options.cwd });
-        discardedCount++;
-      } catch (e) {
-        errors.push(
-          `Failed to fix session ${s.sessionID}: ${e instanceof Error ? e.message : String(e)}`,
-        );
-      }
-    }
-  }
-
-  return { stuckSessions: stuck, fixedCount, discardedCount, errors };
-}