@proletariat/cli 0.3.50 → 0.3.52

package/dist/lib/external-issues/mapper.js

@@ -4,6 +4,7 @@
  * Deterministically maps an IssueEnvelope to spawn context data
  * (prompt text + metadata) for agent execution.
  */
+import { validateOrThrow } from './validation.js';
 /**
  * Map an IssueEnvelope to spawn context data.
  *
@@ -14,10 +15,12 @@
  * The mapping is deterministic: the same IssueEnvelope always produces
  * the same IssueSpawnContext.
  *
- * @param envelope - Validated IssueEnvelope
+ * @param input - IssueEnvelope-like input
  * @returns Spawn context with prompt and metadata
+ * @throws ExternalIssueError when input fails IssueEnvelope validation
  */
-export function mapToSpawnContext(envelope) {
+export function mapToSpawnContext(input) {
+    const envelope = validateOrThrow(input);
     const prompt = buildPrompt(envelope);
     const metadata = buildMetadata(envelope);
     return { prompt, metadata };

package/dist/lib/external-issues/mapping-store.d.ts

@@ -0,0 +1,12 @@
+import Database from 'better-sqlite3';
+import { type ExternalExecutionMapping, type ExternalMappingProvider, type UpsertExternalExecutionMappingInput } from './types.js';
+export declare class ExternalExecutionMappingStore {
+    private db;
+    constructor(db: Database.Database);
+    private ensureTables;
+    upsertMapping(input: UpsertExternalExecutionMappingInput): ExternalExecutionMapping;
+    getByExternalId(provider: ExternalMappingProvider, externalId: string): ExternalExecutionMapping | null;
+    getByExternalKey(provider: ExternalMappingProvider, externalKey: string): ExternalExecutionMapping | null;
+    findByExecutionId(executionId: string): ExternalExecutionMapping[];
+    private rowToMapping;
+}

package/dist/lib/external-issues/mapping-store.js

@@ -0,0 +1,164 @@
+import { PMO_TABLES } from '../pmo/schema.js';
+const T = PMO_TABLES;
+function parseDate(value) {
+    return value ? new Date(value) : null;
+}
+function parseSnapshot(value) {
+    if (!value)
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Keep compatibility if old/invalid values are present.
+    }
+    return null;
+}
+export class ExternalExecutionMappingStore {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.ensureTables();
+    }
+    ensureTables() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${T.external_execution_map} (
+        provider TEXT NOT NULL CHECK (provider IN ('linear', 'jira', 'asana', 'monday', 'pmo')),
+        external_id TEXT NOT NULL,
+        external_key TEXT,
+        canonical_url TEXT,
+        latest_state_snapshot TEXT,
+        last_synced_at TIMESTAMP,
+        last_spawned_at TIMESTAMP,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (provider, external_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS ${T.external_execution_links} (
+        provider TEXT NOT NULL,
+        external_id TEXT NOT NULL,
+        execution_id TEXT NOT NULL,
+        linked_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (provider, external_id, execution_id),
+        FOREIGN KEY (provider, external_id)
+          REFERENCES ${T.external_execution_map}(provider, external_id)
+          ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS ${T.external_execution_prs} (
+        provider TEXT NOT NULL,
+        external_id TEXT NOT NULL,
+        pr_url TEXT NOT NULL,
+        linked_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (provider, external_id, pr_url),
+        FOREIGN KEY (provider, external_id)
+          REFERENCES ${T.external_execution_map}(provider, external_id)
+          ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_pmo_external_execution_map_external_key
+        ON ${T.external_execution_map}(provider, external_key);
+      CREATE INDEX IF NOT EXISTS idx_pmo_external_execution_links_execution_id
+        ON ${T.external_execution_links}(execution_id);
+      CREATE INDEX IF NOT EXISTS idx_pmo_external_execution_prs_pr_url
+        ON ${T.external_execution_prs}(pr_url);
+    `);
+    }
+    upsertMapping(input) {
+        const snapshot = input.latestStateSnapshot === undefined
+            ? null
+            : JSON.stringify(input.latestStateSnapshot);
+        const lastSyncedAt = input.lastSyncedAt?.toISOString() ?? null;
+        const lastSpawnedAt = input.lastSpawnedAt?.toISOString() ?? null;
+        this.db.transaction(() => {
+            this.db.prepare(`
+        INSERT INTO ${T.external_execution_map}
+          (provider, external_id, external_key, canonical_url, latest_state_snapshot, last_synced_at, last_spawned_at, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+        ON CONFLICT(provider, external_id) DO UPDATE SET
+          external_key = COALESCE(excluded.external_key, ${T.external_execution_map}.external_key),
+          canonical_url = COALESCE(excluded.canonical_url, ${T.external_execution_map}.canonical_url),
+          latest_state_snapshot = COALESCE(excluded.latest_state_snapshot, ${T.external_execution_map}.latest_state_snapshot),
+          last_synced_at = COALESCE(excluded.last_synced_at, ${T.external_execution_map}.last_synced_at),
+          last_spawned_at = COALESCE(excluded.last_spawned_at, ${T.external_execution_map}.last_spawned_at),
+          updated_at = CURRENT_TIMESTAMP
+      `).run(input.provider, input.externalId, input.externalKey ?? null, input.canonicalUrl ?? null, snapshot, lastSyncedAt, lastSpawnedAt);
+            if (input.executionId) {
+                this.db.prepare(`
+          INSERT OR IGNORE INTO ${T.external_execution_links}
+            (provider, external_id, execution_id, linked_at)
+          VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+        `).run(input.provider, input.externalId, input.executionId);
+            }
+            if (input.prUrl) {
+                this.db.prepare(`
+          INSERT OR IGNORE INTO ${T.external_execution_prs}
+            (provider, external_id, pr_url, linked_at)
+          VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+        `).run(input.provider, input.externalId, input.prUrl);
+            }
+        })();
+        return this.getByExternalId(input.provider, input.externalId);
+    }
+    getByExternalId(provider, externalId) {
+        const row = this.db.prepare(`
+      SELECT * FROM ${T.external_execution_map}
+      WHERE provider = ? AND external_id = ?
+    `).get(provider, externalId);
+        if (!row)
+            return null;
+        return this.rowToMapping(row);
+    }
+    getByExternalKey(provider, externalKey) {
+        const row = this.db.prepare(`
+      SELECT * FROM ${T.external_execution_map}
+      WHERE provider = ? AND external_key = ?
+    `).get(provider, externalKey);
+        if (!row)
+            return null;
+        return this.rowToMapping(row);
+    }
+    findByExecutionId(executionId) {
+        const rows = this.db.prepare(`
+      SELECT m.*
+      FROM ${T.external_execution_map} m
+      INNER JOIN ${T.external_execution_links} l
+        ON m.provider = l.provider
+       AND m.external_id = l.external_id
+      WHERE l.execution_id = ?
+      ORDER BY m.updated_at DESC
+    `).all(executionId);
+        return rows.map((row) => this.rowToMapping(row));
+    }
+    rowToMapping(row) {
+        const executionIds = this.db.prepare(`
+      SELECT execution_id AS value
+      FROM ${T.external_execution_links}
+      WHERE provider = ? AND external_id = ?
+      ORDER BY linked_at DESC
+    `).all(row.provider, row.external_id);
+        const prUrls = this.db.prepare(`
+      SELECT pr_url AS value
+      FROM ${T.external_execution_prs}
+      WHERE provider = ? AND external_id = ?
+      ORDER BY linked_at DESC
+    `).all(row.provider, row.external_id);
+        return {
+            provider: row.provider,
+            externalId: row.external_id,
+            externalKey: row.external_key,
+            canonicalUrl: row.canonical_url,
+            latestStateSnapshot: parseSnapshot(row.latest_state_snapshot),
+            executionIds: executionIds.map((r) => r.value),
+            prUrls: prUrls.map((r) => r.value),
+            lastSyncedAt: parseDate(row.last_synced_at),
+            lastSpawnedAt: parseDate(row.last_spawned_at),
+            createdAt: new Date(row.created_at),
+            updatedAt: new Date(row.updated_at),
+        };
+    }
+}

package/dist/lib/external-issues/types.d.ts

@@ -14,6 +14,10 @@ export type IssueSource = 'linear' | 'jira';
  * All valid issue sources as a const array.
  */
 export declare const ISSUE_SOURCES: readonly ["linear", "jira"];
+/**
+ * Providers supported by the external execution mapping store.
+ */
+export type ExternalMappingProvider = 'linear' | 'jira' | 'asana' | 'monday' | 'pmo';
 /**
  * Canonical envelope for external issues/work items.
  *
@@ -129,6 +133,36 @@ export interface ExternalIssueAdapter {
      */
     fetchByQuery(query: Record<string, unknown>): Promise<IssueEnvelope[]>;
 }
+/**
+ * Provider-agnostic external issue ↔ execution mapping record.
+ */
+export interface ExternalExecutionMapping {
+    provider: ExternalMappingProvider;
+    externalId: string;
+    externalKey: string | null;
+    canonicalUrl: string | null;
+    latestStateSnapshot: Record<string, unknown> | null;
+    executionIds: string[];
+    prUrls: string[];
+    lastSyncedAt: Date | null;
+    lastSpawnedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Upsert payload for provider-agnostic external issue mapping.
+ */
+export interface UpsertExternalExecutionMappingInput {
+    provider: ExternalMappingProvider;
+    externalId: string;
+    externalKey?: string | null;
+    canonicalUrl?: string | null;
+    latestStateSnapshot?: Record<string, unknown> | null;
+    executionId?: string;
+    prUrl?: string;
+    lastSyncedAt?: Date;
+    lastSpawnedAt?: Date;
+}
 /**
  * Error codes for external issue operations.
  */

package/dist/lib/external-issues/validation.js

@@ -16,6 +16,7 @@ const REQUIRED_STRING_FIELDS = [
     'url',
     'project_key',
 ];
+const PRIORITY_VALUES = new Set(['P0', 'P1', 'P2', 'P3']);
 /**
  * Validate and construct an IssueEnvelope from untyped input.
  *
@@ -145,6 +146,16 @@ export function validateIssueEnvelope(input) {
             message: 'priority must be a string or null',
         });
     }
+    else if (typeof data.priority === 'string') {
+        const normalizedPriority = data.priority.trim().toUpperCase();
+        if (!PRIORITY_VALUES.has(normalizedPriority)) {
+            errors.push({
+                code: 'INVALID_FIELD_TYPE',
+                field: 'priority',
+                message: 'priority must be one of: P0, P1, P2, P3, or null',
+            });
+        }
+    }
     // Validate assignee (string or null)
     if (!('assignee' in data) || data.assignee === undefined) {
         errors.push({

package/dist/lib/external-issues/work-start.d.ts

@@ -0,0 +1,10 @@
+export interface MirrorResolutionInput {
+    flagValue?: boolean;
+    envValue?: boolean | null;
+    configValue?: boolean | null;
+}
+export interface MirrorResolution {
+    enabled: boolean;
+    source: 'flag' | 'env' | 'config' | 'default';
+}
+export declare function resolveMirrorToPmo(input: MirrorResolutionInput): MirrorResolution;

package/dist/lib/external-issues/work-start.js

@@ -0,0 +1,12 @@
+export function resolveMirrorToPmo(input) {
+    if (input.flagValue !== undefined) {
+        return { enabled: input.flagValue, source: 'flag' };
+    }
+    if (input.envValue !== null && input.envValue !== undefined) {
+        return { enabled: input.envValue, source: 'env' };
+    }
+    if (input.configValue !== null && input.configValue !== undefined) {
+        return { enabled: input.configValue, source: 'config' };
+    }
+    return { enabled: true, source: 'default' };
+}

package/dist/lib/linear/mapper.d.ts

@@ -9,6 +9,7 @@ import type { CreateTicketInput, PMOStorage, WorkflowStatus } from '../pmo/types
 import type { LinearIssue, LinearIssueMap, LinearSyncResult } from './types.js';
 export declare class LinearMapper {
     private db;
+    private externalMappingStore;
     constructor(db: Database.Database);
     /**
      * Ensure the linear_issue_map table exists.
@@ -64,4 +65,5 @@ export declare class LinearMapper {
      * Convert a database row to a LinearIssueMap.
      */
     private rowToMap;
+    private externalMappingToLinearMap;
 }

package/dist/lib/linear/mapper.js

@@ -5,11 +5,14 @@
  * Handles import (Linear → PMO) and reverse lookup for sync operations.
  */
 import { PMO_TABLES } from '../pmo/schema.js';
+import { ExternalExecutionMappingStore } from '../external-issues/mapping-store.js';
 import { LINEAR_STATE_TO_PMO_CATEGORY, LINEAR_PRIORITY_TO_PMO, } from './types.js';
 export class LinearMapper {
     db;
+    externalMappingStore;
     constructor(db) {
         this.db = db;
+        this.externalMappingStore = new ExternalExecutionMappingStore(db);
         this.ensureTable();
     }
     /**
@@ -146,6 +149,18 @@ export class LinearMapper {
         (pmo_ticket_id, linear_issue_id, linear_identifier, linear_team_key, linear_url, sync_direction, last_synced_at, created_at)
       VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
     `).run(map.pmoTicketId, map.linearIssueId, map.linearIdentifier, map.linearTeamKey, map.linearUrl, map.syncDirection);
+        this.externalMappingStore.upsertMapping({
+            provider: 'linear',
+            externalId: map.linearIssueId,
+            externalKey: map.linearIdentifier,
+            canonicalUrl: map.linearUrl,
+            latestStateSnapshot: {
+                pmoTicketId: map.pmoTicketId,
+                linearTeamKey: map.linearTeamKey,
+                syncDirection: map.syncDirection,
+            },
+            lastSyncedAt: new Date(),
+        });
     }
     /**
      * Get a mapping by PMO ticket ID.
@@ -163,7 +178,11 @@ export class LinearMapper {
         const row = this.db.prepare(`
       SELECT * FROM ${PMO_TABLES.linear_issue_map} WHERE linear_issue_id = ?
     `).get(linearIssueId);
-        return row ? this.rowToMap(row) : null;
+        if (row) {
+            return this.rowToMap(row);
+        }
+        const mapping = this.externalMappingStore.getByExternalId('linear', linearIssueId);
+        return mapping ? this.externalMappingToLinearMap(mapping) : null;
     }
     /**
      * Get a mapping by Linear identifier (e.g., "ENG-123").
@@ -172,7 +191,11 @@ export class LinearMapper {
         const row = this.db.prepare(`
       SELECT * FROM ${PMO_TABLES.linear_issue_map} WHERE linear_identifier = ?
     `).get(identifier);
-        return row ? this.rowToMap(row) : null;
+        if (row) {
+            return this.rowToMap(row);
+        }
+        const mapping = this.externalMappingStore.getByExternalKey('linear', identifier);
+        return mapping ? this.externalMappingToLinearMap(mapping) : null;
     }
     /**
      * List all mappings.
@@ -192,6 +215,21 @@ export class LinearMapper {
       SET last_synced_at = CURRENT_TIMESTAMP
       WHERE pmo_ticket_id = ?
     `).run(pmoTicketId);
+        const map = this.getByTicketId(pmoTicketId);
+        if (map) {
+            this.externalMappingStore.upsertMapping({
+                provider: 'linear',
+                externalId: map.linearIssueId,
+                externalKey: map.linearIdentifier,
+                canonicalUrl: map.linearUrl,
+                latestStateSnapshot: {
+                    pmoTicketId: map.pmoTicketId,
+                    linearTeamKey: map.linearTeamKey,
+                    syncDirection: map.syncDirection,
+                },
+                lastSyncedAt: new Date(),
+            });
+        }
     }
     /**
      * Delete a mapping by PMO ticket ID.
@@ -216,4 +254,30 @@ export class LinearMapper {
             createdAt: new Date(row.created_at),
         };
     }
+    externalMappingToLinearMap(row) {
+        const snapshot = row.latestStateSnapshot ?? {};
+        const ticketId = typeof snapshot['pmoTicketId'] === 'string' ? snapshot['pmoTicketId'] : null;
+        if (!ticketId) {
+            return null;
+        }
+        const teamKey = typeof snapshot['linearTeamKey'] === 'string'
+            ? snapshot['linearTeamKey']
+            : (typeof snapshot['teamKey'] === 'string' ? snapshot['teamKey'] : null);
+        const resolvedTeamKey = teamKey
+            ? teamKey
+            : (row.externalKey?.split('-')[0] ?? 'UNKNOWN');
+        const syncDirection = typeof snapshot['syncDirection'] === 'string'
+            ? snapshot['syncDirection']
+            : 'inbound';
+        return {
+            pmoTicketId: ticketId,
+            linearIssueId: row.externalId,
+            linearIdentifier: row.externalKey ?? row.externalId,
+            linearTeamKey: resolvedTeamKey,
+            linearUrl: row.canonicalUrl ?? '',
+            syncDirection: syncDirection,
+            lastSyncedAt: row.lastSyncedAt ?? undefined,
+            createdAt: row.createdAt,
+        };
+    }
 }

package/dist/lib/monday/client.d.ts

@@ -0,0 +1,14 @@
+import type { MondayBoard, MondayItem } from './types.js';
+export declare class MondayClient {
+    private apiToken;
+    constructor(apiToken: string);
+    verify(): Promise<{
+        accountName: string;
+        userName: string;
+        email?: string;
+    }>;
+    getBoard(boardId: string): Promise<MondayBoard | null>;
+    createItem(boardId: string, itemName: string): Promise<MondayItem>;
+    updateItemName(boardId: string, itemId: string, name: string): Promise<void>;
+    private request;
+}

package/dist/lib/monday/client.js

@@ -0,0 +1,113 @@
+const MONDAY_API_URL = 'https://api.monday.com/v2';
+export class MondayClient {
+    apiToken;
+    constructor(apiToken) {
+        this.apiToken = apiToken;
+    }
+    async verify() {
+        const data = await this.request(`
+      query VerifyMondayConnection {
+        me {
+          id
+          name
+          email
+        }
+        account {
+          id
+          name
+          slug
+        }
+      }
+    `);
+        return {
+            accountName: data.account.name,
+            userName: data.me.name,
+            email: data.me.email,
+        };
+    }
+    async getBoard(boardId) {
+        const data = await this.request(`
+      query GetBoard($boardIds: [ID!]) {
+        boards(ids: $boardIds) {
+          id
+          name
+          url
+        }
+      }
+    `, { boardIds: [boardId] });
+        if (data.boards.length === 0)
+            return null;
+        return {
+            id: data.boards[0].id,
+            name: data.boards[0].name,
+            url: data.boards[0].url ?? undefined,
+        };
+    }
+    async createItem(boardId, itemName) {
+        const data = await this.request(`
+      mutation CreateItem($boardId: ID!, $itemName: String!) {
+        create_item(board_id: $boardId, item_name: $itemName) {
+          id
+          name
+          url
+        }
+      }
+    `, {
+            boardId,
+            itemName,
+        });
+        return {
+            id: data.create_item.id,
+            name: data.create_item.name,
+            url: data.create_item.url ?? undefined,
+        };
+    }
+    async updateItemName(boardId, itemId, name) {
+        await this.request(`
+      mutation UpdateItemName($boardId: ID!, $itemId: ID!, $value: String!) {
+        change_simple_column_value(
+          board_id: $boardId
+          item_id: $itemId
+          column_id: "name"
+          value: $value
+        ) {
+          id
+        }
+      }
+    `, {
+            boardId,
+            itemId,
+            value: name,
+        });
+    }
+    async request(query, variables) {
+        // eslint-disable-next-line n/no-unsupported-features/node-builtins
+        const response = await fetch(MONDAY_API_URL, {
+            method: 'POST',
+            headers: {
+                Authorization: this.apiToken,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ query, variables }),
+        });
+        const responseText = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(responseText);
+        }
+        catch {
+            throw new Error(`Monday API returned invalid JSON (${response.status}): ${responseText}`);
+        }
+        if (!response.ok) {
+            const message = payload.errors?.[0]?.message ?? responseText;
+            throw new Error(`Monday API request failed (${response.status}): ${message}`);
+        }
+        if (payload.errors && payload.errors.length > 0) {
+            throw new Error(payload.errors[0].message);
+        }
+        if (!payload.data) {
+            throw new Error('Monday API response missing data');
+        }
+        return payload.data;
+    }
+}

package/dist/lib/monday/config.d.ts

@@ -0,0 +1,10 @@
+import Database from 'better-sqlite3';
+import type { MondayConfig } from './types.js';
+export declare function isMondayConfigured(db: Database.Database): boolean;
+export declare function loadMondayConfig(db: Database.Database): MondayConfig | null;
+export declare function saveMondayApiToken(db: Database.Database, apiToken: string): void;
+export declare function saveMondayBoard(db: Database.Database, boardId: string, boardName: string): void;
+export declare function saveMondayAccountName(db: Database.Database, accountName: string): void;
+export declare function clearMondayConfig(db: Database.Database): void;
+export declare function getMondayApiToken(db: Database.Database): string | null;
+export declare function getMondayBoardId(db: Database.Database): string | null;

package/dist/lib/monday/config.js

@@ -0,0 +1,64 @@
+const SETTINGS_TABLE = 'workspace_settings';
+const MONDAY_CONFIG_KEYS = {
+    apiToken: 'monday.api_token',
+    boardId: 'monday.board_id',
+    boardName: 'monday.board_name',
+    accountName: 'monday.account_name',
+};
+function getSetting(db, key) {
+    const row = db
+        .prepare(`SELECT value FROM ${SETTINGS_TABLE} WHERE key = ?`)
+        .get(key);
+    return row?.value ?? null;
+}
+function setSetting(db, key, value) {
+    db.prepare(`
+    INSERT INTO ${SETTINGS_TABLE} (key, value)
+    VALUES (?, ?)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value
+  `).run(key, value);
+}
+function deleteSetting(db, key) {
+    db.prepare(`DELETE FROM ${SETTINGS_TABLE} WHERE key = ?`).run(key);
+}
+export function isMondayConfigured(db) {
+    return getSetting(db, MONDAY_CONFIG_KEYS.apiToken) !== null;
+}
+export function loadMondayConfig(db) {
+    const apiToken = getSetting(db, MONDAY_CONFIG_KEYS.apiToken);
+    if (!apiToken)
+        return null;
+    return {
+        apiToken,
+        boardId: getSetting(db, MONDAY_CONFIG_KEYS.boardId) ?? undefined,
+        boardName: getSetting(db, MONDAY_CONFIG_KEYS.boardName) ?? undefined,
+        accountName: getSetting(db, MONDAY_CONFIG_KEYS.accountName) ?? undefined,
+    };
+}
+export function saveMondayApiToken(db, apiToken) {
+    setSetting(db, MONDAY_CONFIG_KEYS.apiToken, apiToken);
+}
+export function saveMondayBoard(db, boardId, boardName) {
+    setSetting(db, MONDAY_CONFIG_KEYS.boardId, boardId);
+    setSetting(db, MONDAY_CONFIG_KEYS.boardName, boardName);
+}
+export function saveMondayAccountName(db, accountName) {
+    setSetting(db, MONDAY_CONFIG_KEYS.accountName, accountName);
+}
+export function clearMondayConfig(db) {
+    for (const key of Object.values(MONDAY_CONFIG_KEYS)) {
+        deleteSetting(db, key);
+    }
+}
+export function getMondayApiToken(db) {
+    const envToken = process.env.PRLT_MONDAY_API_TOKEN || process.env.MONDAY_API_TOKEN;
+    if (envToken)
+        return envToken;
+    return getSetting(db, MONDAY_CONFIG_KEYS.apiToken);
+}
+export function getMondayBoardId(db) {
+    const envBoardId = process.env.PRLT_MONDAY_BOARD_ID || process.env.MONDAY_BOARD_ID;
+    if (envBoardId)
+        return envBoardId;
+    return getSetting(db, MONDAY_CONFIG_KEYS.boardId);
+}

package/dist/lib/monday/index.d.ts

@@ -0,0 +1,5 @@
+export { MondayClient } from './client.js';
+export { isMondayConfigured, loadMondayConfig, saveMondayApiToken, saveMondayBoard, saveMondayAccountName, clearMondayConfig, getMondayApiToken, getMondayBoardId, } from './config.js';
+export { MondayMapper } from './mapper.js';
+export { MondaySync } from './sync.js';
+export type { MondayBoard, MondayItem, MondayConfig, MondayItemMap, MondaySyncResult, } from './types.js';

package/dist/lib/monday/index.js

@@ -0,0 +1,4 @@
+export { MondayClient } from './client.js';
+export { isMondayConfigured, loadMondayConfig, saveMondayApiToken, saveMondayBoard, saveMondayAccountName, clearMondayConfig, getMondayApiToken, getMondayBoardId, } from './config.js';
+export { MondayMapper } from './mapper.js';
+export { MondaySync } from './sync.js';

package/dist/lib/monday/mapper.d.ts

@@ -0,0 +1,14 @@
+import Database from 'better-sqlite3';
+import type { MondayItemMap } from './types.js';
+export declare class MondayMapper {
+    private db;
+    constructor(db: Database.Database);
+    private ensureTable;
+    createOrUpdateMapping(map: Omit<MondayItemMap, 'lastSyncedAt' | 'createdAt'>): void;
+    getByTicketId(ticketId: string): MondayItemMap | null;
+    getByMondayItemId(itemId: string): MondayItemMap | null;
+    listMappings(): MondayItemMap[];
+    updateSyncTimestamp(ticketId: string): void;
+    deleteMapping(ticketId: string): void;
+    private rowToMap;
+}