npm - github-issue-tower-defence-management - Versions diffs - 1.118.0 → 1.119.0 - Mend

github-issue-tower-defence-management 1.118.0 → 1.119.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (52) hide show

package/src/adapter/entry-points/console/ui-dist/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index-DWiG7btO.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BMe1bEF4.css">
+    <script type="module" crossorigin src="/assets/index-syKbd_lW.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-D0RwhyOM.css">
   </head>
   <body>
     <div id="root"></div>

package/src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts CHANGED Viewed

@@ -120,6 +120,8 @@ export class HandleScheduledEventUseCaseHandler {
       candidateDebounceRecencyWindowSeconds?: number;
       candidateDebounceStateFilePath?: string;
       activeHubTaskStatus?: string;
+      hubTaskStatusCacheStateFilePath?: string;
+      hubTaskStatusCacheTtlSeconds?: number;
       silentMainStalledMessage?: string;
       silentSubAgentIdleMessageHeader?: string;
       silentSubAgentIdleMessageFooter?: string;
@@ -626,6 +628,15 @@ export class HandleScheduledEventUseCaseHandler {
             process.env.TDPM_ACTIVE_HUB_TASK_STATUS ??
             null,
           hubTaskStatusResolver: issueRepository,
+          hubTaskStatusCacheStateFilePath:
+            mergedInput.hubTaskStatusCacheStateFilePath ??
+            process.env.TDPM_SILENT_HUB_TASK_STATUS_CACHE_STATE_FILE_PATH ??
+            null,
+          hubTaskStatusCacheTtlSeconds: readSilentSeconds(
+            mergedInput.hubTaskStatusCacheTtlSeconds,
+            process.env.TDPM_SILENT_HUB_TASK_STATUS_CACHE_TTL_SECONDS,
+            DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS.hubTaskStatusCacheTtlSeconds,
+          ),
           messageTemplates: {
             mainStalledMessage:
               mergedInput.silentMainStalledMessage ??

package/src/adapter/entry-points/handlers/notifySilentTmuxSessions.test.ts CHANGED Viewed

@@ -39,6 +39,7 @@ const createMockRunner = (): Mocked<LocalCommandRunner> => ({
 describe('notifySilentTmuxSessions', () => {
   let configDir: string;
   let candidateStateFilePath: string;
+  let hubTaskStatusCacheStateFilePath: string;
   beforeEach(() => {
     jest.spyOn(console, 'log').mockImplementation(() => undefined);
@@ -47,6 +48,10 @@ describe('notifySilentTmuxSessions', () => {
       configDir,
       'silent-session-candidates.json',
     );
+    hubTaskStatusCacheStateFilePath = path.join(
+      configDir,
+      'silent-session-hub-task-status.json',
+    );
   });
   afterEach(() => {
@@ -136,6 +141,7 @@ describe('notifySilentTmuxSessions', () => {
     candidateDebounceStateFilePath: candidateStateFilePath,
     activeHubTaskStatus: null,
     hubTaskStatusResolver: null,
+    hubTaskStatusCacheStateFilePath: hubTaskStatusCacheStateFilePath,
     messageTemplates: EMPTY_TEMPLATES,
     now: NOW,
     ...DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS,

package/src/adapter/entry-points/handlers/notifySilentTmuxSessions.ts CHANGED Viewed

@@ -10,6 +10,7 @@ import {
   DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
   DEFAULT_NOTIFICATION_STAGGER_SECONDS,
   DEFAULT_CANDIDATE_DEBOUNCE_RECENCY_WINDOW_SECONDS,
+  DEFAULT_HUB_TASK_STATUS_CACHE_TTL_SECONDS,
 } from '../../../domain/usecases/NotifySilentLiveSessionsUseCase';
 import { DefaultSilentSessionMessageComposer } from '../../../domain/usecases/DefaultSilentSessionMessageComposer';
 import { LocalProcessLiveSessionProcessSnapshotProvider } from '../../repositories/LocalProcessLiveSessionProcessSnapshotProvider';
@@ -30,6 +31,7 @@ import {
 } from '../../repositories/ConfigurableSilentSessionMessageComposer';
 import { RealSleeper } from '../../repositories/RealSleeper';
 import { FileSystemSilentSessionCandidateStateRepository } from '../../repositories/FileSystemSilentSessionCandidateStateRepository';
+import { FileSystemSilentSessionHubTaskStatusCacheRepository } from '../../repositories/FileSystemSilentSessionHubTaskStatusCacheRepository';
 export type NotifySilentTmuxSessionsParams = {
   enabled: boolean;
@@ -47,6 +49,8 @@ export type NotifySilentTmuxSessionsParams = {
   candidateDebounceStateFilePath: string | null;
   activeHubTaskStatus: string | null;
   hubTaskStatusResolver: HubTaskStatusResolver | null;
+  hubTaskStatusCacheStateFilePath: string | null;
+  hubTaskStatusCacheTtlSeconds: number;
   messageTemplates: SilentSessionMessageTemplates;
   now: Date;
 };
@@ -104,6 +108,8 @@ export const notifySilentTmuxSessions = async (
     candidateDebounceStateFilePath,
     activeHubTaskStatus,
     hubTaskStatusResolver,
+    hubTaskStatusCacheStateFilePath,
+    hubTaskStatusCacheTtlSeconds,
     messageTemplates,
     now,
   } = params;
@@ -141,6 +147,11 @@ export const notifySilentTmuxSessions = async (
     messageComposer,
     new RealSleeper(),
     hubTaskStatusResolver,
+    hubTaskStatusCacheStateFilePath !== null
+      ? new FileSystemSilentSessionHubTaskStatusCacheRepository(
+          hubTaskStatusCacheStateFilePath,
+        )
+      : new FileSystemSilentSessionHubTaskStatusCacheRepository(),
   );
   await useCase.run({
     mainSilentThresholdSeconds,
@@ -149,6 +160,7 @@ export const notifySilentTmuxSessions = async (
     staggerSeconds,
     candidateDebounceRecencyWindowSeconds,
     activeHubTaskStatus,
+    hubTaskStatusCacheTtlSeconds,
     now,
   });
 };
@@ -160,4 +172,5 @@ export const DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS = {
   staggerSeconds: DEFAULT_NOTIFICATION_STAGGER_SECONDS,
   candidateDebounceRecencyWindowSeconds:
     DEFAULT_CANDIDATE_DEBOUNCE_RECENCY_WINDOW_SECONDS,
+  hubTaskStatusCacheTtlSeconds: DEFAULT_HUB_TASK_STATUS_CACHE_TTL_SECONDS,
 } as const;

package/src/adapter/repositories/FileSystemSilentSessionHubTaskStatusCacheRepository.test.ts ADDED Viewed

@@ -0,0 +1,251 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  DEFAULT_HUB_TASK_STATUS_RETENTION_WINDOW_SECONDS,
+  FileSystemSilentSessionHubTaskStatusCacheRepository,
+} from './FileSystemSilentSessionHubTaskStatusCacheRepository';
+describe('FileSystemSilentSessionHubTaskStatusCacheRepository', () => {
+  let rootDirectory: string;
+  let stateFilePath: string;
+  beforeEach(() => {
+    rootDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'silent-session-hub-task-status-'),
+    );
+    stateFilePath = path.join(
+      rootDirectory,
+      'silent-session-hub-task-status.json',
+    );
+  });
+  afterEach(() => {
+    fs.rmSync(rootDirectory, { force: true, recursive: true });
+  });
+  const issueAlpha = 'https://github.com/HiromiShikata/repo/issues/100';
+  const issueBravo = 'https://github.com/HiromiShikata/repo/issues/200';
+  it('round-trips a saved status so the next cycle reads it back', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+    const now = new Date('2026-06-26T00:00:00Z');
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      now,
+    });
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+    expect(loaded).toEqual({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      recordedEpochSeconds: Math.floor(now.getTime() / 1000),
+    });
+  });
+  it('preserves a null project status across a round-trip', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+    const now = new Date('2026-06-26T00:00:00Z');
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'CLOSED',
+      status: null,
+      now,
+    });
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+    expect(loaded).toEqual({
+      url: issueAlpha,
+      state: 'CLOSED',
+      status: null,
+      recordedEpochSeconds: Math.floor(now.getTime() / 1000),
+    });
+  });
+  it('returns null when no status has been recorded for the url', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+    expect(loaded).toBeNull();
+  });
+  it('returns null when no state file exists yet', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      path.join(rootDirectory, 'missing.json'),
+    );
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+    expect(loaded).toBeNull();
+  });
+  it('returns the most recently recorded status when a url is saved again', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'CLOSED',
+      status: 'Done',
+      now: new Date('2026-06-26T00:01:00Z'),
+    });
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+    expect(loaded?.state).toBe('CLOSED');
+    expect(loaded?.status).toBe('Done');
+  });
+  it('preserves another url recorded by a concurrent run when saving a different url', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+    await repository.saveHubTaskStatus({
+      url: issueBravo,
+      state: 'CLOSED',
+      status: 'Done',
+      now: new Date('2026-06-26T00:00:30Z'),
+    });
+    expect(
+      (await repository.loadHubTaskStatus({ url: issueAlpha }))?.state,
+    ).toBe('OPEN');
+    expect(
+      (await repository.loadHubTaskStatus({ url: issueBravo }))?.state,
+    ).toBe('CLOSED');
+  });
+  it('drops a stored entry that has aged beyond the retention window on the next save', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+      60 * 60,
+    );
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+    await repository.saveHubTaskStatus({
+      url: issueBravo,
+      state: 'OPEN',
+      status: 'In tmux',
+      now: new Date('2026-06-26T01:30:00Z'),
+    });
+    const persisted: unknown = JSON.parse(
+      fs.readFileSync(stateFilePath, 'utf8'),
+    );
+    expect(persisted).toEqual({
+      hubTaskStatuses: [
+        {
+          url: issueBravo,
+          state: 'OPEN',
+          status: 'In tmux',
+          recordedEpochSeconds: Math.floor(
+            new Date('2026-06-26T01:30:00Z').getTime() / 1000,
+          ),
+        },
+      ],
+    });
+  });
+  it('treats a corrupt state file as no recorded status', async () => {
+    fs.writeFileSync(stateFilePath, 'not valid json');
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+    expect(loaded).toBeNull();
+  });
+  it('ignores a malformed stored entry that lacks a valid state', async () => {
+    fs.writeFileSync(
+      stateFilePath,
+      JSON.stringify({
+        hubTaskStatuses: [
+          {
+            url: issueAlpha,
+            state: 'UNKNOWN',
+            status: 'In tmux',
+            recordedEpochSeconds: 1,
+          },
+        ],
+      }),
+    );
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+    const loaded = await repository.loadHubTaskStatus({ url: issueAlpha });
+    expect(loaded).toBeNull();
+  });
+  it('creates the parent directory when the configured path does not exist yet', async () => {
+    const nestedPath = path.join(rootDirectory, 'nested', 'dir', 'state.json');
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      nestedPath,
+    );
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+    expect(fs.existsSync(nestedPath)).toBe(true);
+  });
+  it('writes atomically by renaming a temp file into place leaving no temp file behind', async () => {
+    const repository = new FileSystemSilentSessionHubTaskStatusCacheRepository(
+      stateFilePath,
+    );
+    await repository.saveHubTaskStatus({
+      url: issueAlpha,
+      state: 'OPEN',
+      status: 'In tmux',
+      now: new Date('2026-06-26T00:00:00Z'),
+    });
+    const leftoverTempFiles = fs
+      .readdirSync(rootDirectory)
+      .filter((name) => name.includes('.tmp'));
+    expect(leftoverTempFiles).toEqual([]);
+    expect(fs.existsSync(stateFilePath)).toBe(true);
+  });
+  it('exposes the default retention window as a named constant', () => {
+    expect(DEFAULT_HUB_TASK_STATUS_RETENTION_WINDOW_SECONDS).toBe(60 * 60);
+  });
+});

package/src/adapter/repositories/FileSystemSilentSessionHubTaskStatusCacheRepository.ts ADDED Viewed

@@ -0,0 +1,121 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { Issue } from '../../domain/entities/Issue';
+import {
+  SilentSessionHubTaskStatusCacheEntry,
+  SilentSessionHubTaskStatusCacheRepository,
+} from '../../domain/usecases/adapter-interfaces/SilentSessionHubTaskStatusCacheRepository';
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+const isIssueState = (value: unknown): value is Issue['state'] =>
+  value === 'OPEN' || value === 'CLOSED' || value === 'MERGED';
+export const DEFAULT_HUB_TASK_STATUS_RETENTION_WINDOW_SECONDS = 60 * 60;
+const defaultStateFilePath = (): string => {
+  const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
+  return path.join(base, 'tdpm', 'silent-session-hub-task-status.json');
+};
+export class FileSystemSilentSessionHubTaskStatusCacheRepository implements SilentSessionHubTaskStatusCacheRepository {
+  constructor(
+    private readonly stateFilePath: string = defaultStateFilePath(),
+    private readonly retentionWindowSeconds: number = DEFAULT_HUB_TASK_STATUS_RETENTION_WINDOW_SECONDS,
+  ) {}
+  loadHubTaskStatus = async (params: {
+    url: string;
+  }): Promise<SilentSessionHubTaskStatusCacheEntry | null> => {
+    for (const entry of this.readEntries()) {
+      if (entry.url === params.url) {
+        return entry;
+      }
+    }
+    return null;
+  };
+  saveHubTaskStatus = async (params: {
+    url: string;
+    state: Issue['state'];
+    status: string | null;
+    now: Date;
+  }): Promise<void> => {
+    const recordedEpochSeconds = Math.floor(params.now.getTime() / 1000);
+    const oldestRetainedEpochSeconds =
+      recordedEpochSeconds - this.retentionWindowSeconds;
+    const mergedByUrl = new Map<string, SilentSessionHubTaskStatusCacheEntry>();
+    for (const entry of this.readEntries()) {
+      if (
+        entry.recordedEpochSeconds >= oldestRetainedEpochSeconds &&
+        entry.url !== params.url
+      ) {
+        mergedByUrl.set(entry.url, entry);
+      }
+    }
+    mergedByUrl.set(params.url, {
+      url: params.url,
+      state: params.state,
+      status: params.status,
+      recordedEpochSeconds,
+    });
+    this.writeEntries(Array.from(mergedByUrl.values()));
+  };
+  private readEntries = (): SilentSessionHubTaskStatusCacheEntry[] => {
+    let raw: string;
+    try {
+      raw = fs.readFileSync(this.stateFilePath, 'utf8');
+    } catch {
+      return [];
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+    if (!isRecord(parsed)) {
+      return [];
+    }
+    const storedEntries = parsed.hubTaskStatuses;
+    if (!Array.isArray(storedEntries)) {
+      return [];
+    }
+    const entries: SilentSessionHubTaskStatusCacheEntry[] = [];
+    for (const storedEntry of storedEntries) {
+      if (!isRecord(storedEntry)) {
+        continue;
+      }
+      const url = storedEntry.url;
+      const state = storedEntry.state;
+      const status = storedEntry.status;
+      const recordedEpochSeconds = storedEntry.recordedEpochSeconds;
+      if (
+        typeof url === 'string' &&
+        isIssueState(state) &&
+        (typeof status === 'string' || status === null) &&
+        typeof recordedEpochSeconds === 'number' &&
+        Number.isFinite(recordedEpochSeconds)
+      ) {
+        entries.push({ url, state, status, recordedEpochSeconds });
+      }
+    }
+    return entries;
+  };
+  private writeEntries = (
+    entries: SilentSessionHubTaskStatusCacheEntry[],
+  ): void => {
+    const directory = path.dirname(this.stateFilePath);
+    fs.mkdirSync(directory, { recursive: true });
+    const temporaryPath = `${this.stateFilePath}.${process.pid}.tmp`;
+    fs.writeFileSync(
+      temporaryPath,
+      JSON.stringify({ hubTaskStatuses: entries }),
+    );
+    fs.renameSync(temporaryPath, this.stateFilePath);
+  };
+}