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

package/src/domain/usecases/resolveLabelsAsLlmAgentName.ts

@@ -1,6 +0,0 @@
-export const resolveLabelsAsLlmAgentName = (source: {
-  topLevel?: string[] | null;
-  startPreparation?: string[] | null;
-}): string[] => {
-  return source.topLevel ?? source.startPreparation ?? [];
-};

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

@@ -1,33 +0,0 @@
-import { resolveLabelsNotRequiringPullRequest } from './resolveLabelsNotRequiringPullRequest';
-
-describe('resolveLabelsNotRequiringPullRequest', () => {
-  it('combines both lists so an agent-name label keeps exempting the issue', () => {
-    expect(
-      resolveLabelsNotRequiringPullRequest({
-        labelsAsLlmAgentName: ['chore', 'accounting'],
-        labelsNotRequiringPullRequest: ['story'],
-      }),
-    ).toEqual(['chore', 'accounting', 'story']);
-  });
-
-  it('returns only the agent-name labels when no exemption list is configured', () => {
-    expect(
-      resolveLabelsNotRequiringPullRequest({
-        labelsAsLlmAgentName: ['chore'],
-      }),
-    ).toEqual(['chore']);
-  });
-
-  it('returns only the exemption labels when no agent-name label is configured', () => {
-    expect(
-      resolveLabelsNotRequiringPullRequest({
-        labelsAsLlmAgentName: null,
-        labelsNotRequiringPullRequest: ['story'],
-      }),
-    ).toEqual(['story']);
-  });
-
-  it('returns an empty array when neither list is present', () => {
-    expect(resolveLabelsNotRequiringPullRequest({})).toEqual([]);
-  });
-});

package/src/domain/usecases/resolveLabelsNotRequiringPullRequest.ts

@@ -1,7 +0,0 @@
-export const resolveLabelsNotRequiringPullRequest = (source: {
-  labelsAsLlmAgentName?: string[] | null;
-  labelsNotRequiringPullRequest?: string[] | null;
-}): string[] => [
-  ...(source.labelsAsLlmAgentName ?? []),
-  ...(source.labelsNotRequiringPullRequest ?? []),
-];

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

@@ -1,337 +0,0 @@
-import { AUTO_STATUS_CHECK_MESSAGE_HEAD } from './autoStatusCheckComments';
-import { NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD } from './nextStepAgentDispatchRepeatedMessage';
-import { resolveNextStepAgentDispatchRepetition } from './resolveNextStepAgentDispatchRepetition';
-
-const trustAll = (): boolean => true;
-
-type TestComment = { author: string; content: string };
-
-const report = (nextStepAgent: string, author = 'bot'): TestComment => ({
-  author,
-  content: `From: :robot: agent (model)
-
-\`\`\`json
-{ "nextStepAgent": "${nextStepAgent}" }
-\`\`\`
-
-Report body.`,
-});
-
-const reportWithoutRouting = (author = 'bot'): TestComment => ({
-  author,
-  content: 'From: :robot: agent (model)\n\nReport body with no routing block.',
-});
-
-const repetitionComment = (
-  nextStepAgent: string,
-  author = 'bot',
-): TestComment => ({
-  author,
-  content: `${NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD} ${nextStepAgent}
-
-Dispatching it again.`,
-});
-
-const humanComment = (author = 'bot'): TestComment => ({
-  author,
-  content: 'Please carry on with the second option.',
-});
-
-describe('resolveNextStepAgentDispatchRepetition', () => {
-  describe('silent agent bound', () => {
-    it('returns notRepeated when the agent field holds no value', () => {
-      expect(
-        resolveNextStepAgentDispatchRepetition({
-          agentFieldValue: null,
-          nextStepAgent: 'accounting',
-          comments: [report('accounting')],
-          isTrustedAuthor: trustAll,
-          thresholdForAutoReject: 3,
-          thresholdForDispatchLoop: 6,
-        }),
-      ).toEqual({ type: 'notRepeated' });
-    });
-
-    it('returns notRepeated when the agent field holds another agent', () => {
-      expect(
-        resolveNextStepAgentDispatchRepetition({
-          agentFieldValue: 'triager',
-          nextStepAgent: 'accounting',
-          comments: [report('accounting')],
-          isTrustedAuthor: trustAll,
-          thresholdForAutoReject: 3,
-          thresholdForDispatchLoop: 6,
-        }),
-      ).toEqual({ type: 'notRepeated' });
-    });
-
-    it('returns dispatchAgain with the attempt count when the declared agent is already assigned', () => {
-      const result = resolveNextStepAgentDispatchRepetition({
-        agentFieldValue: 'accounting',
-        nextStepAgent: 'accounting',
-        comments: [report('accounting')],
-        isTrustedAuthor: trustAll,
-        thresholdForAutoReject: 3,
-        thresholdForDispatchLoop: 6,
-      });
-
-      expect(result.type).toBe('dispatchAgain');
-      expect(result.type === 'dispatchAgain' ? result.comment : '').toContain(
-        '(1/3)',
-      );
-    });
-
-    it('matches the agent field and the declared agent ignoring case, spaces and hyphens', () => {
-      expect(
-        resolveNextStepAgentDispatchRepetition({
-          agentFieldValue: 'PR Reviewer',
-          nextStepAgent: 'pr-reviewer',
-          comments: [report('pr-reviewer')],
-          isTrustedAuthor: trustAll,
-          thresholdForAutoReject: 3,
-          thresholdForDispatchLoop: 6,
-        }).type,
-      ).toBe('dispatchAgain');
-    });
-
-    it('counts only repetition comments written by a trusted author', () => {
-      const result = resolveNextStepAgentDispatchRepetition({
-        agentFieldValue: 'accounting',
-        nextStepAgent: 'accounting',
-        comments: [
-          report('accounting', 'bot'),
-          repetitionComment('accounting', 'stranger'),
-          repetitionComment('accounting', 'stranger'),
-        ],
-        isTrustedAuthor: (author: string): boolean => author === 'bot',
-        thresholdForAutoReject: 3,
-        thresholdForDispatchLoop: 6,
-      });
-
-      expect(result.type).toBe('dispatchAgain');
-    });
-
-    it('reports against the dispatch loop threshold, not the silent agent one, when the agent did report', () => {
-      const result = resolveNextStepAgentDispatchRepetition({
-        agentFieldValue: 'chore',
-        nextStepAgent: 'chore',
-        comments: [report('chore'), report('chore')],
-        isTrustedAuthor: trustAll,
-        thresholdForAutoReject: 3,
-        thresholdForDispatchLoop: 6,
-      });
-
-      expect(result.type).toBe('dispatchAgain');
-      const comment = result.type === 'dispatchAgain' ? result.comment : '';
-      expect(comment).toContain('(2/6)');
-      expect(comment).not.toContain('ended without a report');
-    });
-
-    it('escalates once the repetition count reaches the auto reject threshold', () => {
-      const result = resolveNextStepAgentDispatchRepetition({
-        agentFieldValue: 'accounting',
-        nextStepAgent: 'accounting',
-        comments: [
-          report('accounting'),
-          repetitionComment('accounting'),
-          repetitionComment('accounting'),
-        ],
-        isTrustedAuthor: trustAll,
-        thresholdForAutoReject: 3,
-        thresholdForDispatchLoop: 6,
-      });
-
-      expect(result.type).toBe('escalateToFailedPreparation');
-    });
-  });
-
-  describe('dispatch loop bound', () => {
-    it('escalates when two agents alternate until one reaches the dispatch loop threshold', () => {
-      const result = resolveNextStepAgentDispatchRepetition({
-        agentFieldValue: 'analyst',
-        nextStepAgent: 'reviewer',
-        comments: [
-          report('reviewer'),
-          report('analyst'),
-          report('reviewer'),
-          report('analyst'),
-          report('reviewer'),
-        ],
-        isTrustedAuthor: trustAll,
-        thresholdForAutoReject: 3,
-        thresholdForDispatchLoop: 3,
-      });
-
-      expect(result.type).toBe('escalateToFailedPreparation');
-      expect(
-        result.type === 'escalateToFailedPreparation' ? result.comment : '',
-      ).toContain('reviewer');
-    });
-
-    it('escalates when the same agent is named every round while a fresh report arrives each time', () => {
-      const result = resolveNextStepAgentDispatchRepetition({
-        agentFieldValue: 'chore',
-        nextStepAgent: 'chore',
-        comments: [report('chore'), report('chore'), report('chore')],
-        isTrustedAuthor: trustAll,
-        thresholdForAutoReject: 99,
-        thresholdForDispatchLoop: 3,
-      });
-
-      expect(result.type).toBe('escalateToFailedPreparation');
-    });
-
-    it('reports the dispatch count against the dispatch loop threshold before escalating', () => {
-      const result = resolveNextStepAgentDispatchRepetition({
-        agentFieldValue: 'analyst',
-        nextStepAgent: 'reviewer',
-        comments: [report('reviewer'), report('analyst'), report('reviewer')],
-        isTrustedAuthor: trustAll,
-        thresholdForAutoReject: 99,
-        thresholdForDispatchLoop: 3,
-      });
-
-      expect(result.type).toBe('dispatchAgain');
-      expect(result.type === 'dispatchAgain' ? result.comment : '').toContain(
-        '(2/3)',
-      );
-    });
-
-    it('returns notRepeated for a chain of distinct agents', () => {
-      expect(
-        resolveNextStepAgentDispatchRepetition({
-          agentFieldValue: 'analyst',
-          nextStepAgent: 'developer',
-          comments: [
-            report('analyst'),
-            report('reviewer'),
-            report('developer'),
-          ],
-          isTrustedAuthor: trustAll,
-          thresholdForAutoReject: 3,
-          thresholdForDispatchLoop: 3,
-        }),
-      ).toEqual({ type: 'notRepeated' });
-    });
-
-    it('restarts counting after a human comment', () => {
-      const result = resolveNextStepAgentDispatchRepetition({
-        agentFieldValue: 'analyst',
-        nextStepAgent: 'reviewer',
-        comments: [
-          report('reviewer'),
-          report('analyst'),
-          humanComment(),
-          report('reviewer'),
-          report('analyst'),
-          report('reviewer'),
-        ],
-        isTrustedAuthor: trustAll,
-        thresholdForAutoReject: 99,
-        thresholdForDispatchLoop: 3,
-      });
-
-      expect(result.type).toBe('dispatchAgain');
-      expect(result.type === 'dispatchAgain' ? result.comment : '').toContain(
-        '(2/3)',
-      );
-    });
-
-    it('treats a comment from an untrusted author as human input that restarts counting', () => {
-      const result = resolveNextStepAgentDispatchRepetition({
-        agentFieldValue: 'analyst',
-        nextStepAgent: 'reviewer',
-        comments: [
-          report('reviewer', 'bot'),
-          report('analyst', 'bot'),
-          { author: 'stranger', content: 'A drive-by remark.' },
-          report('reviewer', 'bot'),
-          report('analyst', 'bot'),
-          report('reviewer', 'bot'),
-        ],
-        isTrustedAuthor: (author: string): boolean => author === 'bot',
-        thresholdForAutoReject: 99,
-        thresholdForDispatchLoop: 3,
-      });
-
-      expect(result.type).toBe('dispatchAgain');
-    });
-
-    it('does not restart counting on its own repetition comment', () => {
-      const result = resolveNextStepAgentDispatchRepetition({
-        agentFieldValue: 'analyst',
-        nextStepAgent: 'reviewer',
-        comments: [
-          report('reviewer'),
-          report('analyst'),
-          report('reviewer'),
-          repetitionComment('reviewer'),
-          report('analyst'),
-          report('reviewer'),
-        ],
-        isTrustedAuthor: trustAll,
-        thresholdForAutoReject: 99,
-        thresholdForDispatchLoop: 3,
-      });
-
-      expect(result.type).toBe('escalateToFailedPreparation');
-    });
-
-    it('does not restart counting on an auto status check comment', () => {
-      const result = resolveNextStepAgentDispatchRepetition({
-        agentFieldValue: 'analyst',
-        nextStepAgent: 'reviewer',
-        comments: [
-          report('reviewer'),
-          report('analyst'),
-          {
-            author: 'bot',
-            content: `${AUTO_STATUS_CHECK_MESSAGE_HEAD} PULL_REQUEST_NOT_FOUND`,
-          },
-          report('reviewer'),
-          report('analyst'),
-          report('reviewer'),
-        ],
-        isTrustedAuthor: trustAll,
-        thresholdForAutoReject: 99,
-        thresholdForDispatchLoop: 3,
-      });
-
-      expect(result.type).toBe('escalateToFailedPreparation');
-    });
-
-    it('matches the declared agent across reports ignoring case, spaces and hyphens', () => {
-      const result = resolveNextStepAgentDispatchRepetition({
-        agentFieldValue: 'developer',
-        nextStepAgent: 'pr-reviewer',
-        comments: [
-          report('PR Reviewer'),
-          report('developer'),
-          report('pr-reviewer'),
-        ],
-        isTrustedAuthor: trustAll,
-        thresholdForAutoReject: 99,
-        thresholdForDispatchLoop: 2,
-      });
-
-      expect(result.type).toBe('escalateToFailedPreparation');
-    });
-
-    it('ignores reports that declare no next step agent', () => {
-      expect(
-        resolveNextStepAgentDispatchRepetition({
-          agentFieldValue: 'analyst',
-          nextStepAgent: 'reviewer',
-          comments: [
-            reportWithoutRouting(),
-            reportWithoutRouting(),
-            report('reviewer'),
-          ],
-          isTrustedAuthor: trustAll,
-          thresholdForAutoReject: 99,
-          thresholdForDispatchLoop: 3,
-        }),
-      ).toEqual({ type: 'notRepeated' });
-    });
-  });
-});

package/src/domain/usecases/resolveNextStepAgentDispatchRepetition.ts

@@ -1,133 +0,0 @@
-import { normalizeProjectFieldName } from '../entities/ProjectFieldName';
-import { extractNextStepAgent } from './extractNextStepAgent';
-import { findLastAgentReport } from './findLastAgentReport';
-import { isAgentReportBody } from './isAgentReportBody';
-import { isHumanComment } from './isHumanComment';
-import { NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD } from './nextStepAgentDispatchRepeatedMessage';
-
-export { NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD };
-
-export const DEFAULT_THRESHOLD_FOR_DISPATCH_LOOP = 6;
-
-export type NextStepAgentDispatchRepetition =
-  | { type: 'notRepeated' }
-  | { type: 'dispatchAgain'; comment: string }
-  | { type: 'escalateToFailedPreparation'; comment: string };
-
-const countSilentRedispatches = <
-  CommentLike extends { author: string; content: string },
->(params: {
-  agentFieldValue: string | null;
-  nextStepAgent: string;
-  comments: CommentLike[];
-  isTrustedAuthor: (author: string) => boolean;
-}): number | null => {
-  if (
-    params.agentFieldValue === null ||
-    normalizeProjectFieldName(params.agentFieldValue) !==
-      normalizeProjectFieldName(params.nextStepAgent)
-  ) {
-    return null;
-  }
-  const lastAgentReport = findLastAgentReport(
-    params.comments,
-    params.isTrustedAuthor,
-  );
-  const commentsAfterLastAgentReport = lastAgentReport
-    ? params.comments.slice(params.comments.indexOf(lastAgentReport) + 1)
-    : [];
-  return (
-    commentsAfterLastAgentReport.filter(
-      (comment) =>
-        params.isTrustedAuthor(comment.author) &&
-        comment.content.startsWith(
-          NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD,
-        ),
-    ).length + 1
-  );
-};
-
-const countDispatchesInCurrentCycle = <
-  CommentLike extends { author: string; content: string },
->(params: {
-  nextStepAgent: string;
-  comments: CommentLike[];
-  isTrustedAuthor: (author: string) => boolean;
-}): number => {
-  const lastHumanCommentIndex = params.comments.reduce(
-    (found, comment, index) =>
-      isHumanComment(comment, params.isTrustedAuthor) ? index : found,
-    -1,
-  );
-  const reportsInCurrentCycle = params.comments
-    .slice(lastHumanCommentIndex + 1)
-    .filter(
-      (comment) =>
-        params.isTrustedAuthor(comment.author) &&
-        isAgentReportBody(comment.content),
-    );
-  return (
-    reportsInCurrentCycle.slice(0, -1).filter((comment) => {
-      const declared = extractNextStepAgent(comment.content);
-      return (
-        declared !== null &&
-        normalizeProjectFieldName(declared) ===
-          normalizeProjectFieldName(params.nextStepAgent)
-      );
-    }).length + 1
-  );
-};
-
-export const resolveNextStepAgentDispatchRepetition = <
-  CommentLike extends { author: string; content: string },
->(params: {
-  agentFieldValue: string | null;
-  nextStepAgent: string;
-  comments: CommentLike[];
-  isTrustedAuthor: (author: string) => boolean;
-  thresholdForAutoReject: number;
-  thresholdForDispatchLoop: number;
-}): NextStepAgentDispatchRepetition => {
-  const silentRedispatches = countSilentRedispatches(params);
-  if (
-    silentRedispatches !== null &&
-    silentRedispatches >= params.thresholdForAutoReject
-  ) {
-    return {
-      type: 'escalateToFailedPreparation',
-      comment: `${NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD} ${params.nextStepAgent}
-
-Failed to receive a report from the dispatched agent for ${params.thresholdForAutoReject} times`,
-    };
-  }
-  const dispatchesInCycle = countDispatchesInCurrentCycle(params);
-  if (dispatchesInCycle >= params.thresholdForDispatchLoop) {
-    return {
-      type: 'escalateToFailedPreparation',
-      comment: `${NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD} ${params.nextStepAgent}
-
-This agent has been dispatched ${params.thresholdForDispatchLoop} times since the last human comment on this issue and the task has not moved past it, so the issue is escalated for a decision instead of being dispatched again.`,
-    };
-  }
-  const silentRedispatchMessage = {
-    type: 'dispatchAgain' as const,
-    comment: `${NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD} ${params.nextStepAgent}
-
-The latest agent report names this agent as the next step and the agent field already holds it, so the previous dispatch to it ended without a report. Dispatching it again (${silentRedispatches}/${params.thresholdForAutoReject}).`,
-  };
-  if (silentRedispatches !== null && silentRedispatches > 1) {
-    return silentRedispatchMessage;
-  }
-  if (dispatchesInCycle > 1) {
-    return {
-      type: 'dispatchAgain',
-      comment: `${NEXT_STEP_AGENT_DISPATCH_REPEATED_MESSAGE_HEAD} ${params.nextStepAgent}
-
-The latest agent report names this agent as the next step and it has already been dispatched on this issue since the last human comment. Dispatching it again (${dispatchesInCycle}/${params.thresholdForDispatchLoop}).`,
-    };
-  }
-  if (silentRedispatches !== null) {
-    return silentRedispatchMessage;
-  }
-  return { type: 'notRepeated' };
-};

package/src/domain/usecases/silentSessionReminderSentinel.ts

@@ -1,9 +0,0 @@
-// Stable, recognizable marker embedded in every monitor-injected silent-session
-// self-check reminder. It lets owner-reply detection distinguish a reminder that
-// the monitor injected into a session's transcript (which arrives as a user text
-// entry via `tmux send-keys`) from a genuine owner reply, so an injected reminder
-// is never miscounted as the owner answering an outstanding call-to-user. The tag
-// is bracketed and namespaced to make an accidental collision with genuine human
-// owner text effectively impossible.
-export const SILENT_SESSION_REMINDER_SENTINEL =
-  '[TDPM_SILENT_SESSION_SELF_CHECK_REMINDER]';

package/src/domain/usecases/triagerAgentName.ts

@@ -1,4 +0,0 @@
-export const TRIAGER_AGENT_NAME = 'triager';
-
-export const isTriagerAgentName = (agentName: string | null): boolean =>
-  agentName !== null && agentName.trim().toLowerCase() === TRIAGER_AGENT_NAME;

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

@@ -1,35 +0,0 @@
-import { encodeForURI } from './utils';
-
-describe('encodeForURI', () => {
-  it('should return empty string when url is undefined', () => {
-    expect(encodeForURI(undefined)).toBe('');
-  });
-
-  it('should return empty string when url is null', () => {
-    expect(encodeForURI(null)).toBe('');
-  });
-
-  it('should return empty string when url is empty', () => {
-    expect(encodeForURI('')).toBe('');
-  });
-
-  it('should encode a single # character', () => {
-    expect(encodeForURI('foo#bar')).toBe('foo%23bar');
-  });
-
-  it('should encode all occurrences of # in the input', () => {
-    expect(encodeForURI('foo#bar#baz#qux')).toBe('foo%23bar%23baz%23qux');
-  });
-
-  it('should encode a single & character', () => {
-    expect(encodeForURI('foo&bar')).toBe('foo%26bar');
-  });
-
-  it('should encode all occurrences of & in the input', () => {
-    expect(encodeForURI('foo&bar&baz&qux')).toBe('foo%26bar%26baz%26qux');
-  });
-
-  it('should encode all occurrences of both # and & together', () => {
-    expect(encodeForURI('a#b&c#d&e')).toBe('a%23b%26c%23d%26e');
-  });
-});

package/src/domain/usecases/utils.ts

@@ -1,6 +0,0 @@
-export const encodeForURI = (url?: string | null): string => {
-  if (!url) {
-    return '';
-  }
-  return encodeURI(url).replace(/#/g, '%23').replace(/&/g, '%26');
-};

package/src/index.test.ts

@@ -1,8 +0,0 @@
-import { hello } from './index';
-
-describe('index', () => {
-  test('hello', async () => {
-    const res = hello('test');
-    expect(res).toEqual('hello test');
-  });
-});

package/src/index.ts

@@ -1,10 +0,0 @@
-import dotenv from 'dotenv';
-import { HandleScheduledEventUseCaseHandler } from './adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler';
-import { getStoryObjectMap } from './adapter/entry-points/function/getStoryObjectMap';
-dotenv.config();
-export const hello = (name: string) => `hello ${name}`;
-export { Project } from './domain/entities/Project';
-export { Issue } from './domain/entities/Issue';
-export const scheduledEvent = new HandleScheduledEventUseCaseHandler().handle;
-export { getStoryObjectMap };
-export { StoryObject, StoryObjectMap } from './domain/entities/StoryObjectMap';

package/src/releaseConfig.test.ts

@@ -1,40 +0,0 @@
-import { readFileSync } from 'fs';
-import { join } from 'path';
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  value !== null && typeof value === 'object' && !Array.isArray(value);
-
-const isCommitAnalyzerEntry = (
-  plugin: unknown,
-): plugin is [string, Record<string, unknown>] =>
-  Array.isArray(plugin) &&
-  plugin[0] === '@semantic-release/commit-analyzer' &&
-  isRecord(plugin[1]);
-
-const readCommitAnalyzerReleaseRules = (): unknown => {
-  const raw: unknown = JSON.parse(
-    readFileSync(join(__dirname, '..', 'package.json'), 'utf8'),
-  );
-  if (!isRecord(raw) || !isRecord(raw.release)) {
-    throw new Error('package.json must declare a release section');
-  }
-  const plugins = raw.release.plugins;
-  if (!Array.isArray(plugins)) {
-    throw new Error('package.json must declare release.plugins');
-  }
-  const entry = plugins.find(isCommitAnalyzerEntry);
-  if (entry === undefined) {
-    throw new Error(
-      'commit-analyzer plugin must be configured with options in package.json',
-    );
-  }
-  return entry[1].releaseRules;
-};
-
-describe('release config', () => {
-  it('releases a patch version for a revert commit', () => {
-    expect(readCommitAnalyzerReleaseRules()).toEqual(
-      expect.arrayContaining([{ type: 'revert', release: 'patch' }]),
-    );
-  });
-});

package/tsconfig.build.json

@@ -1,18 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": ["src"],
-  "exclude": [
-    "node_modules",
-    "**/__tests__/*",
-    "**/*.test.ts",
-    "src/adapter/entry-points/console/ui/**",
-    "src/adapter/entry-points/console/ui-dist/**"
-  ],
-  "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "bin",
-    "declaration": true,
-    "declarationMap": true,
-    "declarationDir": "types"
-  }
-}

package/tsconfig.json

@@ -1,25 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "lib": ["es2022", "dom", "dom.iterable"],
-    "module": "CommonJS",
-    "moduleResolution": "Node",
-    "esModuleInterop": true,
-    "outDir": "./dist",
-    "sourceMap": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "strictNullChecks": true,
-    "ignoreDeprecations": "6.0",
-    "types": ["jest", "node"]
-  },
-  "include": ["src"],
-  "exclude": [
-    "node_modules",
-    "**/__tests__/*",
-    "src/adapter/entry-points/console/ui/**",
-    "src/adapter/entry-points/console/ui-dist/**"
-  ]
-}