github-issue-tower-defence-management 2.19.1 → 2.19.2

package/src/adapter/repositories/TranscriptSessionSubAgentActivityRepository.ts

@@ -1,459 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { SubAgentActivity } from '../../domain/entities/LiveSessionActivitySnapshot';
-import { SessionSubAgentActivityRepository } from '../../domain/usecases/adapter-interfaces/SessionSubAgentActivityRepository';
-import { SubAgentLivenessResolver } from '../../domain/usecases/adapter-interfaces/SubAgentLivenessResolver';
-import { SubAgentProcessLister } from '../../domain/usecases/adapter-interfaces/SubAgentProcessLister';
-import { SubAgentTranscriptDirectoryResolver } from '../../domain/usecases/adapter-interfaces/SubAgentTranscriptDirectoryResolver';
-
-const alwaysIndeterminateLivenessResolver: SubAgentLivenessResolver = {
-  resolveLiveSubAgentIds: async () => null,
-};
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null;
-
-const readString = (
-  value: Record<string, unknown>,
-  key: string,
-): string | null => {
-  const candidate = value[key];
-  return typeof candidate === 'string' ? candidate : null;
-};
-
-const parseEpochSeconds = (timestamp: string | null): number | null => {
-  if (timestamp === null) {
-    return null;
-  }
-  const parsed = Date.parse(timestamp);
-  return Number.isNaN(parsed) ? null : Math.floor(parsed / 1000);
-};
-
-const PENDING_TOOL_COMMAND_FRAGMENT_LENGTH = 60;
-
-export const normalizeCommandFragment = (command: string): string =>
-  command
-    .replace(/\s+/g, ' ')
-    .trim()
-    .slice(0, PENDING_TOOL_COMMAND_FRAGMENT_LENGTH);
-
-type ParsedTranscript = {
-  firstEntryEpochSeconds: number | null;
-  lastEntryIndicatesCompletion: boolean;
-  pendingToolCommands: string[];
-  pendingDelegationToolUse: boolean;
-};
-
-const readContentBlocks = (
-  message: Record<string, unknown>,
-): Record<string, unknown>[] => {
-  const content = message.content;
-  if (!Array.isArray(content)) {
-    return [];
-  }
-  return content.filter(isRecord);
-};
-
-// Tool whose result marks the sub-agent's final structured answer: once its
-// tool_result is recorded, the sub-agent has delivered its output and is
-// genuinely complete even though the transcript tail is a user entry.
-const COMPLETION_TOOL_NAMES = new Set(['StructuredOutput']);
-
-// Tools that delegate work to a nested child sub-agent. A parent whose
-// transcript tail is a pending tool_use of one of these tools is waiting for
-// the child to run (possibly queued), produces no transcript writes of its
-// own, and therefore looks "silent" by mtime alone. Such a parent is treated
-// as waiting on an external process so it is excluded from both the
-// sub-agent-idle and sub-agent-long-running selections.
-const DELEGATION_TOOL_NAMES = new Set(['Agent', 'Task']);
-
-const entryToolUseNames = (message: Record<string, unknown>): string[] =>
-  readContentBlocks(message)
-    .filter((block) => readString(block, 'type') === 'tool_use')
-    .map((block) => readString(block, 'name'))
-    .filter((name): name is string => name !== null);
-
-const entryIndicatesCompletion = (
-  entry: Record<string, unknown>,
-  precedingAssistantToolUseNames: string[],
-): boolean => {
-  const type = readString(entry, 'type');
-  const message = entry.message;
-  if (!isRecord(message)) {
-    return false;
-  }
-  if (type === 'assistant') {
-    const stopReason = readString(message, 'stop_reason');
-    if (stopReason === 'end_turn' || stopReason === 'stop_sequence') {
-      return true;
-    }
-    const blocks = readContentBlocks(message);
-    const lastBlock = blocks[blocks.length - 1];
-    return lastBlock !== undefined && readString(lastBlock, 'type') === 'text';
-  }
-  if (type === 'user') {
-    const blocks = readContentBlocks(message);
-    if (blocks.length === 0) {
-      return true;
-    }
-    const lastBlock = blocks[blocks.length - 1];
-    const lastBlockType = readString(lastBlock, 'type');
-    if (lastBlockType === 'text') {
-      // A trailing user text entry is an interruption (e.g. "[Request
-      // interrupted by user]"): the sub-agent will not produce further
-      // output, so the transcript is terminal.
-      return true;
-    }
-    if (lastBlockType === 'tool_result') {
-      // A trailing tool_result is an IN-FLIGHT state, not completion: the
-      // sub-agent has just received a tool result and the next assistant
-      // turn is being generated. Treating it as completion made an active
-      // agent flap in and out of the activity snapshot between samples
-      // (tail alternates between pending tool_use and tool_result). Only
-      // the result of an explicit completion tool (see
-      // COMPLETION_TOOL_NAMES) is a genuine terminal state, so completed
-      // agents still drop out of the snapshot.
-      return precedingAssistantToolUseNames.some((name) =>
-        COMPLETION_TOOL_NAMES.has(name),
-      );
-    }
-    return false;
-  }
-  return false;
-};
-
-const entryPendingToolCommands = (entry: Record<string, unknown>): string[] => {
-  const type = readString(entry, 'type');
-  const message = entry.message;
-  if (type !== 'assistant' || !isRecord(message)) {
-    return [];
-  }
-  const commands: string[] = [];
-  for (const block of readContentBlocks(message)) {
-    if (readString(block, 'type') !== 'tool_use') {
-      continue;
-    }
-    const input = block.input;
-    if (!isRecord(input)) {
-      continue;
-    }
-    const command = readString(input, 'command');
-    if (command !== null && command.trim().length > 0) {
-      commands.push(command);
-    }
-  }
-  return commands;
-};
-
-const parseTranscript = (content: string): ParsedTranscript => {
-  let firstEntryEpochSeconds: number | null = null;
-  let lastEntryIndicatesCompletion = false;
-  let pendingToolCommands: string[] = [];
-  let pendingDelegationToolUse = false;
-  let precedingAssistantToolUseNames: string[] = [];
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) {
-      continue;
-    }
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-    if (!isRecord(parsed)) {
-      continue;
-    }
-    const epochSeconds = parseEpochSeconds(readString(parsed, 'timestamp'));
-    if (firstEntryEpochSeconds === null && epochSeconds !== null) {
-      firstEntryEpochSeconds = epochSeconds;
-    }
-    if (isRecord(parsed.message)) {
-      lastEntryIndicatesCompletion = entryIndicatesCompletion(
-        parsed,
-        precedingAssistantToolUseNames,
-      );
-      pendingToolCommands = entryPendingToolCommands(parsed);
-      if (readString(parsed, 'type') === 'assistant') {
-        precedingAssistantToolUseNames = entryToolUseNames(parsed.message);
-        pendingDelegationToolUse = precedingAssistantToolUseNames.some((name) =>
-          DELEGATION_TOOL_NAMES.has(name),
-        );
-      } else {
-        pendingDelegationToolUse = false;
-      }
-    }
-  }
-  return {
-    firstEntryEpochSeconds,
-    lastEntryIndicatesCompletion,
-    pendingToolCommands,
-    pendingDelegationToolUse,
-  };
-};
-
-const clampToZero = (value: number): number => (value > 0 ? value : 0);
-
-const TERMINAL_TASK_NOTIFICATION_STATUSES = new Set([
-  'completed',
-  'killed',
-  'failed',
-  'stopped',
-]);
-
-const parseTerminalAgentIds = (content: string): Set<string> => {
-  const result = new Set<string>();
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) {
-      continue;
-    }
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-    if (!isRecord(parsed)) {
-      continue;
-    }
-    if (readString(parsed, 'type') !== 'queue-operation') {
-      continue;
-    }
-    if (readString(parsed, 'operation') !== 'enqueue') {
-      continue;
-    }
-    const notifContent = readString(parsed, 'content');
-    if (notifContent === null) {
-      continue;
-    }
-    const statusMatch = notifContent.match(/<status>([^<]+)<\/status>/);
-    if (statusMatch === null) {
-      continue;
-    }
-    if (!TERMINAL_TASK_NOTIFICATION_STATUSES.has(statusMatch[1])) {
-      continue;
-    }
-    for (const taskIdMatch of notifContent.matchAll(
-      /<task-id>(a[0-9a-f]+)<\/task-id>/g,
-    )) {
-      result.add(taskIdMatch[1]);
-    }
-  }
-  return result;
-};
-
-export class TranscriptSessionSubAgentActivityRepository implements SessionSubAgentActivityRepository {
-  constructor(
-    private readonly directoryResolver: SubAgentTranscriptDirectoryResolver,
-    private readonly processLister: SubAgentProcessLister,
-    private readonly now: Date,
-    private readonly livenessResolver: SubAgentLivenessResolver = alwaysIndeterminateLivenessResolver,
-    private readonly runtimeRootDirectory: string | null = null,
-  ) {}
-
-  listSubAgentActivitiesBySessionName = async (
-    sessionNames: string[],
-    transcriptPathBySessionName: Map<string, string>,
-  ): Promise<Map<string, SubAgentActivity[]>> => {
-    const result = new Map<string, SubAgentActivity[]>();
-    const nowEpochSeconds = Math.floor(this.now.getTime() / 1000);
-    let normalizedProcessCommandLines: string[] | null = null;
-    const loadNormalizedProcessCommandLines = async (): Promise<string[]> => {
-      if (normalizedProcessCommandLines === null) {
-        const processes = await this.processLister.listProcesses();
-        normalizedProcessCommandLines = processes.map((process) =>
-          process.commandLine.replace(/\s+/g, ' ').trim(),
-        );
-      }
-      return normalizedProcessCommandLines;
-    };
-    for (const sessionName of sessionNames) {
-      const mainTranscriptPath =
-        transcriptPathBySessionName.get(sessionName) ?? null;
-      const directory = this.directoryResolver.resolveSubAgentsDirectory(
-        sessionName,
-        mainTranscriptPath,
-      );
-      if (directory === null) {
-        continue;
-      }
-      const terminalAgentIds = this.loadTerminalAgentIds(mainTranscriptPath);
-      const liveSubAgentIds =
-        await this.livenessResolver.resolveLiveSubAgentIds({
-          sessionName,
-          mainTranscriptPath,
-        });
-      const activities = await this.collectActivities(
-        directory,
-        nowEpochSeconds,
-        terminalAgentIds,
-        liveSubAgentIds,
-        loadNormalizedProcessCommandLines,
-        mainTranscriptPath,
-      );
-      if (activities.length > 0) {
-        result.set(sessionName, activities);
-      }
-    }
-    return result;
-  };
-
-  private loadTerminalAgentIds = (
-    mainTranscriptPath: string | null,
-  ): Set<string> => {
-    if (mainTranscriptPath === null) {
-      return new Set();
-    }
-    let content: string;
-    try {
-      content = fs.readFileSync(mainTranscriptPath, 'utf8');
-    } catch {
-      return new Set();
-    }
-    return parseTerminalAgentIds(content);
-  };
-
-  private resolveOutputFilePath = (
-    mainTranscriptPath: string | null,
-    agentId: string,
-  ): string | null => {
-    if (this.runtimeRootDirectory === null || mainTranscriptPath === null) {
-      return null;
-    }
-    const slug = path.basename(path.dirname(mainTranscriptPath));
-    const sid = path.basename(mainTranscriptPath, '.jsonl');
-    if (slug.length === 0 || slug === '.' || sid.length === 0) {
-      return null;
-    }
-    return path.join(
-      this.runtimeRootDirectory,
-      slug,
-      sid,
-      'tasks',
-      `${agentId}.output`,
-    );
-  };
-
-  private collectActivities = async (
-    directory: string,
-    nowEpochSeconds: number,
-    terminalAgentIds: Set<string>,
-    liveSubAgentIds: Set<string> | null,
-    loadNormalizedProcessCommandLines: () => Promise<string[]>,
-    mainTranscriptPath: string | null,
-  ): Promise<SubAgentActivity[]> => {
-    let entries: fs.Dirent[];
-    try {
-      entries = fs.readdirSync(directory, { withFileTypes: true });
-    } catch {
-      return [];
-    }
-    const activities: SubAgentActivity[] = [];
-    for (const entry of entries) {
-      const fileName = entry.name;
-      if (!fileName.startsWith('agent-') || !fileName.endsWith('.jsonl')) {
-        continue;
-      }
-      const agentId = fileName.slice('agent-'.length, -'.jsonl'.length);
-      if (terminalAgentIds.has(agentId)) {
-        continue;
-      }
-      if (liveSubAgentIds !== null && !liveSubAgentIds.has(agentId)) {
-        continue;
-      }
-      if (liveSubAgentIds === null && this.runtimeRootDirectory !== null) {
-        const outputFilePath = this.resolveOutputFilePath(
-          mainTranscriptPath,
-          agentId,
-        );
-        const outputFileExists =
-          outputFilePath !== null && fs.existsSync(outputFilePath);
-        if (!outputFileExists) {
-          const processCommandLines = await loadNormalizedProcessCommandLines();
-          const appearsInProcess = processCommandLines.some((line) =>
-            line.includes(agentId),
-          );
-          if (!appearsInProcess) {
-            continue;
-          }
-        }
-      }
-      const filePath = path.join(directory, fileName);
-      const activity = await this.toActivity(
-        filePath,
-        fileName,
-        nowEpochSeconds,
-        liveSubAgentIds !== null,
-        loadNormalizedProcessCommandLines,
-      );
-      if (activity !== null) {
-        activities.push(activity);
-      }
-    }
-    return activities;
-  };
-
-  private toActivity = async (
-    filePath: string,
-    fileName: string,
-    nowEpochSeconds: number,
-    listedInRunningSubAgentsRecord: boolean,
-    loadNormalizedProcessCommandLines: () => Promise<string[]>,
-  ): Promise<SubAgentActivity | null> => {
-    let content: string;
-    let stats: fs.Stats;
-    try {
-      content = fs.readFileSync(filePath, 'utf8');
-      stats = fs.statSync(filePath);
-    } catch {
-      return null;
-    }
-    const transcript = parseTranscript(content);
-    if (
-      transcript.lastEntryIndicatesCompletion &&
-      !listedInRunningSubAgentsRecord
-    ) {
-      return null;
-    }
-    const silentSeconds = clampToZero(
-      nowEpochSeconds - Math.floor(stats.mtimeMs / 1000),
-    );
-    const runningSeconds =
-      transcript.firstEntryEpochSeconds === null
-        ? 0
-        : clampToZero(nowEpochSeconds - transcript.firstEntryEpochSeconds);
-    return {
-      label: fileName.replace(/\.jsonl$/, ''),
-      silentSeconds,
-      runningSeconds,
-      waitingOnExternalProcess:
-        transcript.pendingDelegationToolUse ||
-        (await this.hasLiveMatchingProcess(
-          transcript.pendingToolCommands,
-          loadNormalizedProcessCommandLines,
-        )),
-      finishedResultUnconsumed: transcript.lastEntryIndicatesCompletion,
-    };
-  };
-
-  private hasLiveMatchingProcess = async (
-    pendingToolCommands: string[],
-    loadNormalizedProcessCommandLines: () => Promise<string[]>,
-  ): Promise<boolean> => {
-    if (pendingToolCommands.length === 0) {
-      return false;
-    }
-    const fragments = pendingToolCommands
-      .map(normalizeCommandFragment)
-      .filter((fragment) => fragment.length > 0);
-    if (fragments.length === 0) {
-      return false;
-    }
-    const processCommandLines = await loadNormalizedProcessCommandLines();
-    return fragments.some((fragment) =>
-      processCommandLines.some((commandLine) => commandLine.includes(fragment)),
-    );
-  };
-}

package/src/adapter/repositories/clSessionScopeUnitName.test.ts

@@ -1,76 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { toTmuxSessionName } from '../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
-import { clSessionScopeUnitName } from './clSessionScopeUnitName';
-
-const issueUrls = [
-  'https://github.com/HiromiShikata/secretary/issues/1261',
-  'https://github.com/owner/repo/issues/9',
-  'https://github.com/owner/repo/pull/42',
-];
-
-const sessionNames = [
-  ...issueUrls,
-  ...issueUrls.map((url) => toTmuxSessionName(url)),
-  'idle_no_task_session',
-  'plain-session',
-  'ALLCAPS123',
-];
-
-const canonicalScopeLibPath = (): string | null => {
-  const explicitPath = process.env.CL_SCOPE_LIB_PATH;
-  if (explicitPath !== undefined && existsSync(explicitPath)) {
-    return explicitPath;
-  }
-  const defaultPath = join(
-    homedir(),
-    'git',
-    'secretary',
-    'machine',
-    'sk',
-    'sh',
-    'cl-scope-lib.sh',
-  );
-  return existsSync(defaultPath) ? defaultPath : null;
-};
-
-describe('clSessionScopeUnitName cross-component contract', () => {
-  it('derives a systemd-safe scope unit name of the form cl-<safe>.scope for every session form', () => {
-    for (const sessionName of sessionNames) {
-      const unitName = clSessionScopeUnitName(sessionName);
-      expect(unitName.startsWith('cl-')).toBe(true);
-      expect(unitName.endsWith('.scope')).toBe(true);
-      const core = unitName.slice(0, -'.scope'.length);
-      expect(/^[A-Za-z0-9._-]+$/.test(core)).toBe(true);
-    }
-  });
-
-  it('collapses a raw issue URL and its tmux-normalized session name to the same scope unit name', () => {
-    for (const url of issueUrls) {
-      expect(clSessionScopeUnitName(toTmuxSessionName(url))).toBe(
-        clSessionScopeUnitName(url),
-      );
-    }
-  });
-
-  const libPath = canonicalScopeLibPath();
-  const canonicalContractTest = libPath === null ? it.skip : it;
-  canonicalContractTest(
-    'matches the canonical cl_scope_unit_name derivation shared with cl',
-    () => {
-      if (libPath === null) {
-        return;
-      }
-      for (const sessionName of sessionNames) {
-        const canonicalUnitName = execFileSync(
-          'bash',
-          [libPath, 'unit-name', sessionName],
-          { encoding: 'utf8' },
-        );
-        expect(clSessionScopeUnitName(sessionName)).toBe(canonicalUnitName);
-      }
-    },
-  );
-});

package/src/adapter/repositories/clSessionScopeUnitName.ts

@@ -1,5 +0,0 @@
-export const clSessionScopeUnitName = (sessionName: string): string => {
-  const safe = sessionName.replace(/[^a-zA-Z0-9]/g, '-');
-  const raw = `cl-${safe}`;
-  return `${raw.replace(/[^a-zA-Z0-9._-]/g, '-')}.scope`;
-};

package/src/adapter/repositories/clSessionScopeUnitNameFromCgroupContent.test.ts

@@ -1,34 +0,0 @@
-import { clSessionScopeUnitNameFromCgroupContent } from './clSessionScopeUnitNameFromCgroupContent';
-
-describe('clSessionScopeUnitNameFromCgroupContent', () => {
-  it('extracts the cl-*.scope unit from a cgroup v2 single-hierarchy line', () => {
-    const cgroupContent =
-      '0::/user.slice/user-1000.slice/user@1000.service/app.slice/cl-https---github-com-owner-repo-issues-9.scope\n';
-
-    const result = clSessionScopeUnitNameFromCgroupContent(cgroupContent);
-
-    expect(result).toBe('cl-https---github-com-owner-repo-issues-9.scope');
-  });
-
-  it('extracts the cl-*.scope unit from a multi-hierarchy cgroup v1 file', () => {
-    const cgroupContent = [
-      '12:pids:/user.slice/user-1000.slice/user@1000.service/app.slice/cl-leader-session.scope',
-      '11:cpu,cpuacct:/user.slice/user-1000.slice/user@1000.service/app.slice/cl-leader-session.scope',
-      '0::/user.slice/user-1000.slice/user@1000.service/app.slice/cl-leader-session.scope',
-      '',
-    ].join('\n');
-
-    const result = clSessionScopeUnitNameFromCgroupContent(cgroupContent);
-
-    expect(result).toBe('cl-leader-session.scope');
-  });
-
-  it('returns null when no cl-*.scope unit is present', () => {
-    const cgroupContent =
-      '0::/user.slice/user-1000.slice/user@1000.service/app.slice/vte-spawn-abc.scope\n';
-
-    const result = clSessionScopeUnitNameFromCgroupContent(cgroupContent);
-
-    expect(result).toBeNull();
-  });
-});

package/src/adapter/repositories/clSessionScopeUnitNameFromCgroupContent.ts

@@ -1,8 +0,0 @@
-const CL_SESSION_SCOPE_UNIT_PATTERN = /cl-[A-Za-z0-9._-]+\.scope/;
-
-export const clSessionScopeUnitNameFromCgroupContent = (
-  cgroupContent: string,
-): string | null => {
-  const match = cgroupContent.match(CL_SESSION_SCOPE_UNIT_PATTERN);
-  return match ? match[0] : null;
-};