github-issue-tower-defence-management 1.97.3 → 1.98.0

package/src/adapter/repositories/ProcClaudeInteractiveSessionRepository.ts

@@ -0,0 +1,138 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  ClaudeInteractiveSession,
+  ClaudeInteractiveSessionRepository,
+} from '../../domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository';
+
+const DEFAULT_PROC_DIRECTORY = '/proc';
+const OAUTH_TOKEN_ENVIRON_KEY = 'CLAUDE_CODE_OAUTH_TOKEN';
+const SESSION_ID_ENVIRON_KEY = 'CLAUDE_CODE_SESSION_ID';
+const NAME_ARGUMENT = '--name';
+const TAKE_OWNERSHIP_MARKER = 'Take ownership';
+
+const isIssueUrl = (value: string): boolean =>
+  value.startsWith('http://') || value.startsWith('https://');
+
+const parseCommandLineArguments = (cmdline: string): string[] =>
+  cmdline.split('\0').filter((argument) => argument.length > 0);
+
+const extractIssueUrl = (commandArguments: string[]): string | null => {
+  for (let index = 0; index < commandArguments.length - 1; index += 1) {
+    if (commandArguments[index] === NAME_ARGUMENT) {
+      const value = commandArguments[index + 1] ?? '';
+      if (isIssueUrl(value)) {
+        return value;
+      }
+    }
+  }
+  return null;
+};
+
+const isTakeOwnershipSpawn = (commandArguments: string[]): boolean =>
+  commandArguments.some((argument) => argument.includes(TAKE_OWNERSHIP_MARKER));
+
+export class ProcClaudeInteractiveSessionRepository implements ClaudeInteractiveSessionRepository {
+  constructor(
+    private readonly procDirectory: string = DEFAULT_PROC_DIRECTORY,
+  ) {}
+
+  listInteractiveSessions = (): ClaudeInteractiveSession[] => {
+    const interactiveSessions: ClaudeInteractiveSession[] = [];
+    for (const pidDirectory of this.listProcessIdDirectories()) {
+      const interactiveSession = this.readInteractiveSession(pidDirectory);
+      if (interactiveSession !== null) {
+        interactiveSessions.push(interactiveSession);
+      }
+    }
+    return interactiveSessions;
+  };
+
+  private listProcessIdDirectories = (): string[] => {
+    let entries: string[];
+    try {
+      entries = fs.readdirSync(this.procDirectory);
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => /^\d+$/.test(entry));
+  };
+
+  private readInteractiveSession = (
+    processIdDirectory: string,
+  ): ClaudeInteractiveSession | null => {
+    const commandArguments = this.readCommandArguments(processIdDirectory);
+    if (commandArguments === null) {
+      return null;
+    }
+    if (isTakeOwnershipSpawn(commandArguments)) {
+      return null;
+    }
+    const issueUrl = extractIssueUrl(commandArguments);
+    if (issueUrl === null) {
+      return null;
+    }
+    const environ = this.readEnviron(processIdDirectory);
+    if (environ === null) {
+      return null;
+    }
+    const token = environ.get(OAUTH_TOKEN_ENVIRON_KEY);
+    const sessionId = environ.get(SESSION_ID_ENVIRON_KEY);
+    if (
+      token === undefined ||
+      token.length === 0 ||
+      sessionId === undefined ||
+      sessionId.length === 0
+    ) {
+      return null;
+    }
+    return { token, sessionId, issueUrl };
+  };
+
+  private readCommandArguments = (
+    processIdDirectory: string,
+  ): string[] | null => {
+    const cmdlinePath = path.join(
+      this.procDirectory,
+      processIdDirectory,
+      'cmdline',
+    );
+    let raw: string;
+    try {
+      raw = fs.readFileSync(cmdlinePath, 'utf8');
+    } catch {
+      return null;
+    }
+    return parseCommandLineArguments(raw);
+  };
+
+  private readEnviron = (
+    processIdDirectory: string,
+  ): Map<string, string> | null => {
+    const environPath = path.join(
+      this.procDirectory,
+      processIdDirectory,
+      'environ',
+    );
+    let raw: string;
+    try {
+      raw = fs.readFileSync(environPath, 'utf8');
+    } catch {
+      return null;
+    }
+    const environ = new Map<string, string>();
+    for (const entry of raw.split('\0')) {
+      if (entry.length === 0) {
+        continue;
+      }
+      const separatorIndex = entry.indexOf('=');
+      if (separatorIndex <= 0) {
+        continue;
+      }
+      const key = entry.slice(0, separatorIndex);
+      const value = entry.slice(separatorIndex + 1);
+      environ.set(key, value);
+    }
+    return environ;
+  };
+}

package/src/domain/usecases/InTmuxByHumanSessionTokenCountUseCase.test.ts

@@ -0,0 +1,169 @@
+import { Issue } from '../entities/Issue';
+import {
+  AWAITING_QUALITY_CHECK_STATUS_NAME,
+  IN_TMUX_STATUS_NAME,
+} from '../entities/WorkflowStatus';
+import { ClaudeInteractiveSession } from './adapter-interfaces/ClaudeInteractiveSessionRepository';
+import { InTmuxByHumanSessionTokenCountUseCase } from './InTmuxByHumanSessionTokenCountUseCase';
+import { OauthTokenCandidate } from './OauthTokenSelectUseCase';
+
+const candidate = (name: string): OauthTokenCandidate => ({
+  name,
+  token: `fake-token-${name}`,
+  snapshot: null,
+});
+
+const session = (
+  name: string,
+  sessionId: string,
+  issueUrl: string,
+): ClaudeInteractiveSession => ({
+  token: `fake-token-${name}`,
+  sessionId,
+  issueUrl,
+});
+
+const issue = (url: string, status: string): Issue => ({
+  nameWithOwner: 'HiromiShikata/example',
+  number: 1,
+  title: 'Example issue',
+  state: 'OPEN',
+  status,
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url,
+  assignees: ['hiromi'],
+  labels: [],
+  org: 'HiromiShikata',
+  repo: 'example',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date('2026-01-01T00:00:00Z'),
+  author: 'hiromi',
+});
+
+describe('InTmuxByHumanSessionTokenCountUseCase', () => {
+  const useCase = new InTmuxByHumanSessionTokenCountUseCase();
+  const issueUrlA = 'https://github.com/HiromiShikata/example/issues/1';
+  const issueUrlB = 'https://github.com/HiromiShikata/example/issues/2';
+
+  it('counts a session whose issue is in In-Tmux-by-human status', () => {
+    const result = useCase.run(
+      [candidate('alpha')],
+      [session('alpha', 'session-a', issueUrlA)],
+      [issue(issueUrlA, IN_TMUX_STATUS_NAME)],
+    );
+
+    const alpha = result.counts.find((entry) => entry.name === 'alpha');
+    expect(alpha?.count).toBe(1);
+  });
+
+  it('does not count a session whose issue is in another status', () => {
+    const result = useCase.run(
+      [candidate('alpha')],
+      [session('alpha', 'session-a', issueUrlA)],
+      [issue(issueUrlA, AWAITING_QUALITY_CHECK_STATUS_NAME)],
+    );
+
+    const alpha = result.counts.find((entry) => entry.name === 'alpha');
+    expect(alpha?.count).toBe(0);
+  });
+
+  it('does not count a session whose issue is closed even in In-Tmux-by-human status', () => {
+    const closedIssue: Issue = {
+      ...issue(issueUrlA, IN_TMUX_STATUS_NAME),
+      isClosed: true,
+    };
+    const result = useCase.run(
+      [candidate('alpha')],
+      [session('alpha', 'session-a', issueUrlA)],
+      [closedIssue],
+    );
+
+    const alpha = result.counts.find((entry) => entry.name === 'alpha');
+    expect(alpha?.count).toBe(0);
+  });
+
+  it('dedupes distinct sessions sharing one session id under the same token', () => {
+    const result = useCase.run(
+      [candidate('alpha')],
+      [
+        session('alpha', 'session-a', issueUrlA),
+        session('alpha', 'session-a', issueUrlA),
+        session('alpha', 'session-a', issueUrlA),
+      ],
+      [issue(issueUrlA, IN_TMUX_STATUS_NAME)],
+    );
+
+    const alpha = result.counts.find((entry) => entry.name === 'alpha');
+    expect(alpha?.count).toBe(1);
+  });
+
+  it('counts distinct session ids separately under the same token', () => {
+    const result = useCase.run(
+      [candidate('alpha')],
+      [
+        session('alpha', 'session-a', issueUrlA),
+        session('alpha', 'session-b', issueUrlB),
+      ],
+      [
+        issue(issueUrlA, IN_TMUX_STATUS_NAME),
+        issue(issueUrlB, IN_TMUX_STATUS_NAME),
+      ],
+    );
+
+    const alpha = result.counts.find((entry) => entry.name === 'alpha');
+    expect(alpha?.count).toBe(2);
+  });
+
+  it('reports counts per token across multiple tokens', () => {
+    const result = useCase.run(
+      [candidate('alpha'), candidate('beta')],
+      [
+        session('alpha', 'session-a', issueUrlA),
+        session('beta', 'session-b', issueUrlB),
+      ],
+      [
+        issue(issueUrlA, IN_TMUX_STATUS_NAME),
+        issue(issueUrlB, AWAITING_QUALITY_CHECK_STATUS_NAME),
+      ],
+    );
+
+    expect(result.counts).toEqual([
+      { name: 'alpha', token: 'fake-token-alpha', count: 1 },
+      { name: 'beta', token: 'fake-token-beta', count: 0 },
+    ]);
+
+    const beta = result.counts.find((entry) => entry.name === 'beta');
+    expect(beta?.count).toBe(0);
+  });
+
+  it('reports zero for a token with no matching interactive session', () => {
+    const result = useCase.run(
+      [candidate('lonely')],
+      [session('other', 'session-x', issueUrlA)],
+      [issue(issueUrlA, IN_TMUX_STATUS_NAME)],
+    );
+
+    const lonely = result.counts.find((entry) => entry.name === 'lonely');
+    expect(lonely?.count).toBe(0);
+  });
+
+  it('ignores a session whose issue url is not present among the issues', () => {
+    const result = useCase.run(
+      [candidate('alpha')],
+      [session('alpha', 'session-a', issueUrlB)],
+      [issue(issueUrlA, IN_TMUX_STATUS_NAME)],
+    );
+
+    const alpha = result.counts.find((entry) => entry.name === 'alpha');
+    expect(alpha?.count).toBe(0);
+  });
+});

package/src/domain/usecases/InTmuxByHumanSessionTokenCountUseCase.ts

@@ -0,0 +1,63 @@
+import { Issue } from '../entities/Issue';
+import { IN_TMUX_STATUS_NAME } from '../entities/WorkflowStatus';
+import { ClaudeInteractiveSession } from './adapter-interfaces/ClaudeInteractiveSessionRepository';
+import { OauthTokenCandidate } from './OauthTokenSelectUseCase';
+
+export type InTmuxByHumanSessionTokenCount = {
+  name: string;
+  token: string;
+  count: number;
+};
+
+export type InTmuxByHumanSessionTokenCountResult = {
+  counts: InTmuxByHumanSessionTokenCount[];
+};
+
+export class InTmuxByHumanSessionTokenCountUseCase {
+  run = (
+    candidates: OauthTokenCandidate[],
+    interactiveSessions: ClaudeInteractiveSession[],
+    issues: Issue[],
+  ): InTmuxByHumanSessionTokenCountResult => {
+    const inTmuxByHumanIssueUrls = this.inTmuxByHumanIssueUrls(issues);
+    const distinctSessionIdsByToken = this.distinctSessionIdsByToken(
+      interactiveSessions,
+      inTmuxByHumanIssueUrls,
+    );
+
+    const counts = candidates.map((candidate) => ({
+      name: candidate.name,
+      token: candidate.token,
+      count: distinctSessionIdsByToken.get(candidate.token)?.size ?? 0,
+    }));
+
+    return { counts };
+  };
+
+  private inTmuxByHumanIssueUrls = (issues: Issue[]): Set<string> => {
+    const urls = new Set<string>();
+    for (const issue of issues) {
+      if (issue.status === IN_TMUX_STATUS_NAME && issue.isClosed === false) {
+        urls.add(issue.url);
+      }
+    }
+    return urls;
+  };
+
+  private distinctSessionIdsByToken = (
+    interactiveSessions: ClaudeInteractiveSession[],
+    inTmuxByHumanIssueUrls: Set<string>,
+  ): Map<string, Set<string>> => {
+    const sessionIdsByToken = new Map<string, Set<string>>();
+    for (const session of interactiveSessions) {
+      if (!inTmuxByHumanIssueUrls.has(session.issueUrl)) {
+        continue;
+      }
+      const sessionIds =
+        sessionIdsByToken.get(session.token) ?? new Set<string>();
+      sessionIds.add(session.sessionId);
+      sessionIdsByToken.set(session.token, sessionIds);
+    }
+    return sessionIdsByToken;
+  };
+}

package/src/domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository.ts

@@ -0,0 +1,9 @@
+export type ClaudeInteractiveSession = {
+  token: string;
+  sessionId: string;
+  issueUrl: string;
+};
+
+export interface ClaudeInteractiveSessionRepository {
+  listInteractiveSessions: () => ClaudeInteractiveSession[];
+}

package/types/adapter/entry-points/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/cli/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EACL,UAAU,EACV,cAAc,EACd,wBAAwB,EACxB,YAAY,EACZ,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AAwGzB,eAAO,MAAM,OAAO,SAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/cli/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EACL,UAAU,EACV,cAAc,EACd,wBAAwB,EACxB,YAAY,EACZ,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AA+GzB,eAAO,MAAM,OAAO,SAAgB,CAAC"}

package/types/adapter/entry-points/handlers/InTmuxByHumanSessionTokenCountHandler.d.ts

@@ -0,0 +1,18 @@
+import { Issue } from '../../../domain/entities/Issue';
+import { ClaudeInteractiveSessionRepository } from '../../../domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository';
+import { InTmuxByHumanSessionTokenCountUseCase } from '../../../domain/usecases/InTmuxByHumanSessionTokenCountUseCase';
+export type InTmuxByHumanSessionTokenCountHandlerInput = {
+    tokenListJsonPath: string | null;
+    issues: Issue[];
+};
+export type InTmuxByHumanSessionTokenCountHandlerOutput = {
+    lines: string[];
+    diagnostics: string[];
+};
+export declare class InTmuxByHumanSessionTokenCountHandler {
+    private readonly useCase;
+    private readonly interactiveSessionRepository;
+    constructor(useCase?: InTmuxByHumanSessionTokenCountUseCase, interactiveSessionRepository?: ClaudeInteractiveSessionRepository);
+    handle: (input: InTmuxByHumanSessionTokenCountHandlerInput) => InTmuxByHumanSessionTokenCountHandlerOutput;
+}
+//# sourceMappingURL=InTmuxByHumanSessionTokenCountHandler.d.ts.map

package/types/adapter/entry-points/handlers/InTmuxByHumanSessionTokenCountHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InTmuxByHumanSessionTokenCountHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/InTmuxByHumanSessionTokenCountHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,kCAAkC,EAAE,MAAM,gFAAgF,CAAC;AACpI,OAAO,EAAE,qCAAqC,EAAE,MAAM,gEAAgE,CAAC;AAMvH,MAAM,MAAM,0CAA0C,GAAG;IACvD,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,2CAA2C,GAAG;IACxD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF,qBAAa,qCAAqC;IAE9C,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,4BAA4B;gBAD5B,OAAO,GAAE,qCAAmF,EAC5F,4BAA4B,GAAE,kCAAiF;IAGlI,MAAM,GACJ,OAAO,0CAA0C,KAChD,2CAA2C,CAiD5C;CACH"}

package/types/adapter/repositories/ProcClaudeInteractiveSessionRepository.d.ts

@@ -0,0 +1,11 @@
+import { ClaudeInteractiveSession, ClaudeInteractiveSessionRepository } from '../../domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository';
+export declare class ProcClaudeInteractiveSessionRepository implements ClaudeInteractiveSessionRepository {
+    private readonly procDirectory;
+    constructor(procDirectory?: string);
+    listInteractiveSessions: () => ClaudeInteractiveSession[];
+    private listProcessIdDirectories;
+    private readInteractiveSession;
+    private readCommandArguments;
+    private readEnviron;
+}
+//# sourceMappingURL=ProcClaudeInteractiveSessionRepository.d.ts.map

package/types/adapter/repositories/ProcClaudeInteractiveSessionRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcClaudeInteractiveSessionRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/ProcClaudeInteractiveSessionRepository.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,wBAAwB,EACxB,kCAAkC,EACnC,MAAM,6EAA6E,CAAC;AA6BrF,qBAAa,sCAAuC,YAAW,kCAAkC;IAE7F,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,GAAE,MAA+B;IAGjE,uBAAuB,QAAO,wBAAwB,EAAE,CAStD;IAEF,OAAO,CAAC,wBAAwB,CAQ9B;IAEF,OAAO,CAAC,sBAAsB,CA6B5B;IAEF,OAAO,CAAC,oBAAoB,CAe1B;IAEF,OAAO,CAAC,WAAW,CA4BjB;CACH"}

package/types/domain/usecases/InTmuxByHumanSessionTokenCountUseCase.d.ts

@@ -0,0 +1,17 @@
+import { Issue } from '../entities/Issue';
+import { ClaudeInteractiveSession } from './adapter-interfaces/ClaudeInteractiveSessionRepository';
+import { OauthTokenCandidate } from './OauthTokenSelectUseCase';
+export type InTmuxByHumanSessionTokenCount = {
+    name: string;
+    token: string;
+    count: number;
+};
+export type InTmuxByHumanSessionTokenCountResult = {
+    counts: InTmuxByHumanSessionTokenCount[];
+};
+export declare class InTmuxByHumanSessionTokenCountUseCase {
+    run: (candidates: OauthTokenCandidate[], interactiveSessions: ClaudeInteractiveSession[], issues: Issue[]) => InTmuxByHumanSessionTokenCountResult;
+    private inTmuxByHumanIssueUrls;
+    private distinctSessionIdsByToken;
+}
+//# sourceMappingURL=InTmuxByHumanSessionTokenCountUseCase.d.ts.map

package/types/domain/usecases/InTmuxByHumanSessionTokenCountUseCase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InTmuxByHumanSessionTokenCountUseCase.d.ts","sourceRoot":"","sources":["../../../src/domain/usecases/InTmuxByHumanSessionTokenCountUseCase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1C,OAAO,EAAE,wBAAwB,EAAE,MAAM,yDAAyD,CAAC;AACnG,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAEhE,MAAM,MAAM,8BAA8B,GAAG;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG;IACjD,MAAM,EAAE,8BAA8B,EAAE,CAAC;CAC1C,CAAC;AAEF,qBAAa,qCAAqC;IAChD,GAAG,GACD,YAAY,mBAAmB,EAAE,EACjC,qBAAqB,wBAAwB,EAAE,EAC/C,QAAQ,KAAK,EAAE,KACd,oCAAoC,CAcrC;IAEF,OAAO,CAAC,sBAAsB,CAQ5B;IAEF,OAAO,CAAC,yBAAyB,CAe/B;CACH"}

package/types/domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository.d.ts

@@ -0,0 +1,9 @@
+export type ClaudeInteractiveSession = {
+    token: string;
+    sessionId: string;
+    issueUrl: string;
+};
+export interface ClaudeInteractiveSessionRepository {
+    listInteractiveSessions: () => ClaudeInteractiveSession[];
+}
+//# sourceMappingURL=ClaudeInteractiveSessionRepository.d.ts.map

package/types/domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClaudeInteractiveSessionRepository.d.ts","sourceRoot":"","sources":["../../../../src/domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,wBAAwB,GAAG;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,WAAW,kCAAkC;IACjD,uBAAuB,EAAE,MAAM,wBAAwB,EAAE,CAAC;CAC3D"}