npm - github-issue-tower-defence-management - Versions diffs - 1.86.0 → 1.88.0 - Mend

github-issue-tower-defence-management 1.86.0 → 1.88.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 (64) hide show

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

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <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-DcOZ02ON.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-DFxrSRH4.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

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

@@ -3,6 +3,7 @@ import TYPIA from 'typia';
 import fs from 'fs';
 import { writeSituationFile } from './situationFileWriter';
 import { writeConsoleLists } from './consoleListsWriter';
+import { writeInTmuxByHumanData } from './inTmuxByHumanDataWriter';
 import { writeRotationOrderFile } from './rotationOrderFileWriter';
 import {
   fetchProjectReadme,
@@ -68,6 +69,10 @@ export class HandleScheduledEventUseCaseHandler {
     type inputType = Parameters<HandleScheduledEventUseCase['run']>[0] & {
       claudeCodeOauthTokenListJsonPath?: string;
       consoleDataOutputDir?: string;
+      inTmuxDataOutputDir?: string;
+      inTmuxConsoleBaseUrl?: string;
+      inTmuxConsoleToken?: string;
+      inTmuxProjectOrder?: string[];
       credentials: {
         manager: {
           github: {
@@ -383,6 +388,27 @@ export class HandleScheduledEventUseCaseHandler {
           }`,
         );
       }
+      try {
+        writeInTmuxByHumanData({
+          inTmuxDataOutputDir: mergedInput.inTmuxDataOutputDir ?? null,
+          inTmuxConsoleBaseUrl: mergedInput.inTmuxConsoleBaseUrl ?? null,
+          inTmuxConsoleToken: mergedInput.inTmuxConsoleToken ?? null,
+          inTmuxProjectOrder: mergedInput.inTmuxProjectOrder ?? null,
+          pjcode: input.projectName,
+          assigneeLogin: input.manager,
+          org: input.org,
+          repo: input.workingReport.repo,
+          project: result.project,
+          issues: result.issues,
+        });
+      } catch (error) {
+        console.error(
+          `Failed to write in-tmux-by-human data: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
     }
     return result;
   };

package/src/adapter/entry-points/handlers/inTmuxByHumanDataWriter.test.ts ADDED Viewed

@@ -0,0 +1,266 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { Issue } from '../../../domain/entities/Issue';
+import { FieldOption, Project } from '../../../domain/entities/Project';
+import { writeInTmuxByHumanData } from './inTmuxByHumanDataWriter';
+const ASSIGNEE = 'owner-login';
+const CONSOLE_BASE_URL = 'https://console.example.test';
+const CONSOLE_TOKEN = 'test-token-value';
+const option = (
+  id: string,
+  name: string,
+  color: FieldOption['color'],
+): FieldOption => ({ id, name, color, description: '' });
+const project: Project = {
+  id: 'project-node-id',
+  url: 'https://github.com/orgs/demo/projects/1',
+  databaseId: 1,
+  name: 'demo',
+  status: {
+    name: 'Status',
+    fieldId: 'status-field',
+    statuses: [option('st-tmux', 'In Tmux by human', 'RED')],
+  },
+  nextActionDate: null,
+  nextActionHour: null,
+  story: {
+    name: 'story',
+    fieldId: 'story-field',
+    databaseId: 2,
+    stories: [option('s1', 'Story Alpha', 'BLUE')],
+    workflowManagementStory: { id: 'wm', name: 'workflow management' },
+  },
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+};
+const makeIssue = (overrides: Partial<Issue>): Issue => ({
+  nameWithOwner: 'demo/repo',
+  number: 1,
+  title: 'Issue 1',
+  state: 'OPEN',
+  status: 'In Tmux by human',
+  story: 'Story Alpha',
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: 'https://github.com/demo/repo/issues/1',
+  assignees: [ASSIGNEE],
+  labels: [],
+  org: 'demo',
+  repo: 'repo',
+  body: 'should never be written',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date('2026-06-13T08:18:45.000Z'),
+  author: 'someone',
+  ...overrides,
+});
+const baseParams = (outDir: string) => ({
+  inTmuxDataOutputDir: outDir,
+  inTmuxConsoleBaseUrl: CONSOLE_BASE_URL,
+  inTmuxConsoleToken: CONSOLE_TOKEN,
+  inTmuxProjectOrder: ['demo'],
+  pjcode: 'demo',
+  assigneeLogin: ASSIGNEE,
+  org: 'demo-org',
+  repo: 'demo-repo',
+  project,
+  issues: [makeIssue({})],
+});
+const readJson = (filePath: string): unknown =>
+  JSON.parse(fs.readFileSync(filePath, 'utf8'));
+describe('writeInTmuxByHumanData', () => {
+  let outDir: string;
+  beforeEach(() => {
+    outDir = fs.mkdtempSync(path.join(os.tmpdir(), 'intmux-out-'));
+  });
+  afterEach(() => {
+    fs.rmSync(outDir, { recursive: true, force: true });
+  });
+  const file = (name: string): string => path.join(outDir, name);
+  it('writes the four per-project files and the four index files', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    for (const name of [
+      'demo.json',
+      'demo.v2.json',
+      'demo.v3.json',
+      'demo.v4.json',
+      'index.json',
+      'index.v2.json',
+      'index.v3.json',
+      'index.v4.json',
+    ]) {
+      expect(fs.existsSync(file(name))).toBe(true);
+    }
+  });
+  it('writes pretty-printed JSON ending with a trailing newline', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    const raw = fs.readFileSync(file('demo.json'), 'utf8');
+    expect(raw.endsWith('\n')).toBe(true);
+    expect(raw).toContain('\n  ');
+  });
+  it('writes the v1 shape with a flat url string array', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('demo.json'))).toEqual([
+      {
+        story: 'Story Alpha',
+        urls: ['https://github.com/demo/repo/issues/1'],
+      },
+    ]);
+  });
+  it('writes the v2 shape with url and title objects', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('demo.v2.json'))).toEqual([
+      {
+        story: 'Story Alpha',
+        urls: [
+          { url: 'https://github.com/demo/repo/issues/1', title: 'Issue 1' },
+        ],
+      },
+    ]);
+  });
+  it('writes the v3 document with overviewUrl and a token-free console url', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('demo.v3.json'))).toEqual({
+      version: 3,
+      overviewUrl: 'https://github.com/orgs/demo/projects/1',
+      tdpmConsoleUrl: 'https://console.example.test/projects/demo/prs',
+      groups: [
+        {
+          story: 'Story Alpha',
+          urls: [
+            { url: 'https://github.com/demo/repo/issues/1', title: 'Issue 1' },
+          ],
+        },
+      ],
+    });
+  });
+  it('writes the v4 document with the token-bearing console url and derived new issue url', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('demo.v4.json'))).toEqual({
+      version: 4,
+      overviewUrl: 'https://github.com/orgs/demo/projects/1',
+      tdpmConsoleUrl:
+        'https://console.example.test/projects/demo/prs?k=test-token-value',
+      newIssueUrl:
+        'https://github.com/demo-org/demo-repo/issues/new?assignees=owner-login',
+      groups: [
+        {
+          story: 'Story Alpha',
+          sessions: [
+            {
+              name: 'https://github.com/demo/repo/issues/1',
+              description: 'Issue 1',
+            },
+          ],
+        },
+      ],
+    });
+  });
+  it('writes index files listing configured projects whose per-project file exists', () => {
+    fs.writeFileSync(file('xmile.json'), '[]\n');
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      inTmuxProjectOrder: ['demo', 'xmile', 'xcare'],
+    });
+    expect(readJson(file('index.json'))).toEqual({
+      projects: ['demo', 'xmile'],
+    });
+    expect(readJson(file('index.v2.json'))).toEqual({
+      version: 2,
+      projects: ['demo', 'xmile'],
+    });
+    expect(readJson(file('index.v3.json'))).toEqual({
+      version: 3,
+      projects: ['demo', 'xmile'],
+    });
+  });
+  it('builds the v4 index path from the output dir basename and the token', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    const basename = path.basename(outDir);
+    expect(readJson(file('index.v4.json'))).toEqual({
+      version: 4,
+      projects: [
+        { name: 'demo', path: `/${basename}/demo.v4.json?k=test-token-value` },
+      ],
+    });
+  });
+  it('skips the v4 file and the v4 index when the token is unset but still writes v1, v2, v3 and v1-v3 index', () => {
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      inTmuxConsoleToken: undefined,
+    });
+    expect(fs.existsSync(file('demo.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v2.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v3.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v4.json'))).toBe(false);
+    expect(fs.existsSync(file('index.json'))).toBe(true);
+    expect(fs.existsSync(file('index.v3.json'))).toBe(true);
+    expect(fs.existsSync(file('index.v4.json'))).toBe(false);
+  });
+  it('skips the v3 and v4 files when the console base url is unset', () => {
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      inTmuxConsoleBaseUrl: undefined,
+    });
+    expect(fs.existsSync(file('demo.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v2.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v3.json'))).toBe(false);
+    expect(fs.existsSync(file('demo.v4.json'))).toBe(false);
+  });
+  it('skips the index files when the project order is empty', () => {
+    writeInTmuxByHumanData({ ...baseParams(outDir), inTmuxProjectOrder: [] });
+    expect(fs.existsSync(file('demo.json'))).toBe(true);
+    expect(fs.existsSync(file('index.json'))).toBe(false);
+  });
+  it('does not leave a temp file behind after writing', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(fs.existsSync(`${file('demo.json')}.tmp`)).toBe(false);
+  });
+  it('is a no-op when the output dir is unset', () => {
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      inTmuxDataOutputDir: undefined,
+    });
+    expect(fs.readdirSync(outDir)).toHaveLength(0);
+  });
+  it('is a no-op when pjcode is unset', () => {
+    writeInTmuxByHumanData({ ...baseParams(outDir), pjcode: '' });
+    expect(fs.readdirSync(outDir)).toHaveLength(0);
+  });
+  it('is a no-op when the assignee login is unset', () => {
+    writeInTmuxByHumanData({ ...baseParams(outDir), assigneeLogin: null });
+    expect(fs.readdirSync(outDir)).toHaveLength(0);
+  });
+});

package/src/adapter/entry-points/handlers/inTmuxByHumanDataWriter.ts ADDED Viewed

@@ -0,0 +1,103 @@
+import fs from 'fs';
+import path from 'path';
+import type { Issue } from '../../../domain/entities/Issue';
+import type { Project } from '../../../domain/entities/Project';
+import {
+  GenerateInTmuxByHumanDataUseCase,
+  InTmuxByHumanData,
+} from '../../../domain/usecases/intmux/GenerateInTmuxByHumanDataUseCase';
+export type InTmuxByHumanDataWriterParams = {
+  inTmuxDataOutputDir: string | null | undefined;
+  inTmuxConsoleBaseUrl: string | null | undefined;
+  inTmuxConsoleToken: string | null | undefined;
+  inTmuxProjectOrder: string[] | null | undefined;
+  pjcode: string | null | undefined;
+  assigneeLogin: string | null | undefined;
+  org: string;
+  repo: string;
+  project: Project;
+  issues: Issue[];
+};
+const writeJsonAtomic = (filePath: string, data: unknown): void => {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, `${JSON.stringify(data, null, 2)}\n`);
+  fs.renameSync(tmpPath, filePath);
+};
+export const writeInTmuxByHumanData = (
+  params: InTmuxByHumanDataWriterParams,
+): void => {
+  const {
+    inTmuxDataOutputDir,
+    inTmuxConsoleBaseUrl,
+    inTmuxConsoleToken,
+    inTmuxProjectOrder,
+    pjcode,
+    assigneeLogin,
+    org,
+    repo,
+    project,
+    issues,
+  } = params;
+  if (!inTmuxDataOutputDir || !pjcode || !assigneeLogin) {
+    return;
+  }
+  const data: InTmuxByHumanData = new GenerateInTmuxByHumanDataUseCase().run({
+    project,
+    issues,
+    pjcode,
+    assigneeLogin,
+    org,
+    repo,
+    consoleBaseUrl: inTmuxConsoleBaseUrl ?? null,
+    consoleToken: inTmuxConsoleToken ?? null,
+  });
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, `${pjcode}.json`), data.v1);
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, `${pjcode}.v2.json`), data.v2);
+  if (data.v3) {
+    writeJsonAtomic(
+      path.join(inTmuxDataOutputDir, `${pjcode}.v3.json`),
+      data.v3,
+    );
+  }
+  if (data.v4) {
+    writeJsonAtomic(
+      path.join(inTmuxDataOutputDir, `${pjcode}.v4.json`),
+      data.v4,
+    );
+  }
+  if (!inTmuxProjectOrder || inTmuxProjectOrder.length === 0) {
+    return;
+  }
+  const presentProjects = inTmuxProjectOrder.filter((name) =>
+    fs.existsSync(path.join(inTmuxDataOutputDir, `${name}.json`)),
+  );
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, 'index.json'), {
+    projects: presentProjects,
+  });
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, 'index.v2.json'), {
+    version: 2,
+    projects: presentProjects,
+  });
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, 'index.v3.json'), {
+    version: 3,
+    projects: presentProjects,
+  });
+  if (inTmuxConsoleToken) {
+    const outputDirBasename = path.basename(inTmuxDataOutputDir);
+    writeJsonAtomic(path.join(inTmuxDataOutputDir, 'index.v4.json'), {
+      version: 4,
+      projects: presentProjects.map((name) => ({
+        name,
+        path: `/${outputDirBasename}/${name}.v4.json?k=${inTmuxConsoleToken}`,
+      })),
+    });
+  }
+};