@proletariat/cli 0.3.51 → 0.3.52

package/dist/commands/work/start.js

@@ -13,10 +13,14 @@ import { getWorkspaceInfo, createEphemeralAgent, getTicketTmuxSession, killTmuxS
 import { generateBranchName, DEFAULT_EXECUTION_CONFIG, } from '../../lib/execution/types.js';
 import { runExecution, isDockerRunning, isGitHubTokenAvailable, isDevcontainerCliInstalled, dockerCredentialsExist, getDockerCredentialInfo, isClaudeExecutor, getExecutorDisplayName } from '../../lib/execution/runners.js';
 import { ExecutionStorage, ContainerStorage } from '../../lib/execution/storage.js';
-import { loadExecutionConfig, getTerminalApp, promptTerminalPreference, getShell, promptShellPreference, hasTerminalPreference, hasShellPreference, getOrPromptCoderName, getAuthMethod, saveAuthMethod, getCreatePrDefault } from '../../lib/execution/config.js';
+import { loadExecutionConfig, getTerminalApp, promptTerminalPreference, getShell, promptShellPreference, hasTerminalPreference, hasShellPreference, getOrPromptCoderName, getAuthMethod, saveAuthMethod, getCreatePrDefault, getMirrorToPmoDefault } from '../../lib/execution/config.js';
 import { hasDevcontainerConfig } from '../../lib/execution/devcontainer.js';
 import { detectRepoWorktrees, resolveWorktreePath } from '../../lib/execution/context.js';
 import { isGHInstalled, isGHAuthenticated } from '../../lib/pr/index.js';
+import { buildLinearMetadata, buildLinearSpawnContextMessage, buildLinearTicketDescription, getLinearIssueByIdentifier, } from '../../lib/external-issues/linear.js';
+import { buildJiraMetadata, buildJiraSpawnContextMessage, buildJiraTicketDescription, getJiraIssueByKey, } from '../../lib/external-issues/jira.js';
+import { resolveMirrorToPmo } from '../../lib/external-issues/work-start.js';
+import { ExternalIssueAdapterError } from '../../lib/external-issues/types.js';
 /**
  * Try to execute a git command, return true if successful
  */
@@ -67,6 +71,49 @@ function getActiveStaffAgents(workspaceInfo, log) {
     }
     return result;
 }
+function parseBooleanSetting(value) {
+    if (!value)
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'true')
+        return true;
+    if (normalized === 'false')
+        return false;
+    return null;
+}
+function isIssueSource(value) {
+    return value === 'linear' || value === 'jira';
+}
+function buildExternalMetadata(envelope) {
+    return envelope.source.name === 'jira'
+        ? buildJiraMetadata(envelope)
+        : buildLinearMetadata(envelope);
+}
+function buildExternalTicketDescription(envelope) {
+    return envelope.source.name === 'jira'
+        ? buildJiraTicketDescription(envelope)
+        : buildLinearTicketDescription(envelope);
+}
+function buildExternalSpawnContextMessage(envelope, additionalMessage) {
+    return envelope.source.name === 'jira'
+        ? buildJiraSpawnContextMessage(envelope, additionalMessage)
+        : buildLinearSpawnContextMessage(envelope, additionalMessage);
+}
+function getTicketExternalMetadata(ticket) {
+    const metadata = (typeof ticket === 'object'
+        && ticket !== null
+        && 'metadata' in ticket
+        && typeof ticket.metadata === 'object'
+        && ticket.metadata !== null
+        ? ticket.metadata
+        : {});
+    return {
+        source: typeof metadata.external_source === 'string' ? metadata.external_source : undefined,
+        key: typeof metadata.external_key === 'string' ? metadata.external_key : undefined,
+        id: typeof metadata.external_id === 'string' ? metadata.external_id : undefined,
+        url: typeof metadata.external_url === 'string' ? metadata.external_url : undefined,
+    };
+}
 export default class WorkStart extends PMOCommand {
     static description = 'Start work on a ticket (launches an agent to implement it)';
     static examples = [
@@ -78,6 +125,8 @@ export default class WorkStart extends PMOCommand {
         '<%= config.bin %> <%= command.id %>  # Interactive mode',
         '<%= config.bin %> <%= command.id %> --all  # Spawn all backlog tickets',
         '<%= config.bin %> <%= command.id %> TKT-001 --prompt "Add unit tests for the API"  # Custom prompt',
+        '<%= config.bin %> <%= command.id %> --from-issue --source linear --key ENG-123',
+        '<%= config.bin %> <%= command.id %> --from-issue --source jira --key PROJ-123 --mirror-to-pmo',
     ];
     static args = {
         ticketId: Args.string({
@@ -108,6 +157,21 @@ export default class WorkStart extends PMOCommand {
         message: Flags.string({
             description: 'Additional instructions appended to any action prompt',
         }),
+        'from-issue': Flags.boolean({
+            description: 'Start from external issue source instead of internal ticket id',
+            default: false,
+        }),
+        source: Flags.string({
+            description: 'External issue source',
+            options: ['linear', 'jira'],
+        }),
+        key: Flags.string({
+            description: 'External issue key (for example: ENG-123, PROJ-456)',
+        }),
+        'mirror-to-pmo': Flags.boolean({
+            description: 'Mirror external issue data into PMO ticket (default from execution.mirror_to_pmo_default or PRLT_MIRROR_TO_PMO_DEFAULT)',
+            allowNo: true,
+        }),
         watch: Flags.boolean({
             char: 'w',
             description: 'Stream output in real-time',
@@ -187,9 +251,95 @@ export default class WorkStart extends PMOCommand {
             hidden: true,
         }),
     };
+    async findLinkedTicketByEnvelope(projectId, envelope) {
+        const tickets = await this.storage.listTickets(projectId);
+        return tickets.find((ticket) => {
+            const external = getTicketExternalMetadata(ticket);
+            return external.source === envelope.source.name
+                && (external.key === envelope.source.externalKey || external.id === envelope.source.externalId);
+        });
+    }
+    async createOrUpdateLinkedTicket(projectId, envelope) {
+        const existing = await this.findLinkedTicketByEnvelope(projectId, envelope);
+        const description = buildExternalTicketDescription(envelope);
+        const metadata = buildExternalMetadata(envelope);
+        if (existing) {
+            return this.storage.updateTicket(existing.id, {
+                title: envelope.title,
+                description,
+                priority: envelope.priority ?? undefined,
+                category: envelope.category ?? undefined,
+                labels: envelope.labels,
+                metadata: {
+                    ...existing.metadata,
+                    ...metadata,
+                },
+            });
+        }
+        return this.storage.createTicket(projectId, {
+            title: envelope.title,
+            description,
+            priority: envelope.priority ?? undefined,
+            category: envelope.category ?? undefined,
+            labels: envelope.labels,
+            metadata,
+        });
+    }
+    async fetchExternalIssue(source, key) {
+        if (source === 'jira') {
+            return getJiraIssueByKey({}, key);
+        }
+        return getLinearIssueByIdentifier({}, key);
+    }
+    async resolveIssueSourceAndKey(input, jsonMode) {
+        let source = input.source;
+        let key = input.key;
+        const sourceResolver = new FlagResolver({
+            commandName: 'work start',
+            baseCommand: 'prlt work start --from-issue',
+            jsonMode,
+            flags: {},
+        });
+        sourceResolver.addPrompt({
+            flagName: 'source',
+            type: 'list',
+            message: 'Select external issue source:',
+            default: isIssueSource(source) ? source : undefined,
+            when: () => !isIssueSource(source),
+            choices: () => [
+                { name: 'Linear', value: 'linear', command: 'prlt work start --from-issue --source linear --json' },
+                { name: 'Jira', value: 'jira', command: 'prlt work start --from-issue --source jira --json' },
+            ],
+        });
+        const sourceResult = await sourceResolver.resolve();
+        source = source ?? sourceResult.source;
+        if (!isIssueSource(source)) {
+            throw new Error('Invalid source');
+        }
+        const keyResolver = new FlagResolver({
+            commandName: 'work start',
+            baseCommand: `prlt work start --from-issue --source ${source}`,
+            jsonMode,
+            flags: {},
+        });
+        keyResolver.addPrompt({
+            flagName: 'key',
+            type: 'input',
+            message: `Enter ${source === 'linear' ? 'Linear' : 'Jira'} issue key:`,
+            default: key,
+            when: () => !key?.trim(),
+            validate: (value) => value.trim().length > 0 ? true : 'Issue key is required',
+        });
+        const keyResult = await keyResolver.resolve();
+        const resolvedKey = (key ?? keyResult.key ?? '').trim();
+        if (!resolvedKey) {
+            throw new Error('Issue key is required');
+        }
+        return { source, key: resolvedKey };
+    }
     async execute() {
         const { args, flags } = await this.parse(WorkStart);
-        const projectId = flags.project;
+        let projectId = flags.project;
         // Check for conflicting PR flags
         if (flags['create-pr'] && flags['no-pr']) {
             this.error('--create-pr and --no-pr are mutually exclusive');
@@ -239,6 +389,71 @@ export default class WorkStart extends PMOCommand {
             }
             // Get ticketId - prompt if not provided
             let ticketId = args.ticketId;
+            let externalIssueContextMessage;
+            let fromIssueMirror;
+            let fromIssueMirrorSource;
+            if (flags['from-issue']) {
+                if (ticketId) {
+                    db.close();
+                    return handleError('INVALID_FLAGS', 'Cannot provide a ticket ID positional argument when using --from-issue.');
+                }
+                projectId = projectId || await this.requireProject({
+                    jsonMode: {
+                        flags,
+                        commandName: 'work start',
+                        baseCommand: 'prlt work start --from-issue',
+                    },
+                });
+                const sourceAndKey = await this.resolveIssueSourceAndKey({
+                    source: flags.source,
+                    key: flags.key,
+                }, jsonMode);
+                const envMirrorDefault = parseBooleanSetting(process.env.PRLT_MIRROR_TO_PMO_DEFAULT);
+                const configMirrorDefault = getMirrorToPmoDefault(db);
+                const mirrorResolution = resolveMirrorToPmo({
+                    flagValue: flags['mirror-to-pmo'],
+                    envValue: envMirrorDefault,
+                    configValue: configMirrorDefault,
+                });
+                const mirrorToPmo = mirrorResolution.enabled;
+                fromIssueMirror = mirrorToPmo;
+                fromIssueMirrorSource = mirrorResolution.source;
+                if (!jsonMode) {
+                    this.log(styles.muted(`External issue mirror: ${mirrorToPmo ? 'enabled' : 'disabled'} (${mirrorResolution.source})`));
+                }
+                let envelope = null;
+                try {
+                    envelope = await this.fetchExternalIssue(sourceAndKey.source, sourceAndKey.key);
+                }
+                catch (error) {
+                    if (error instanceof ExternalIssueAdapterError) {
+                        db.close();
+                        return handleError(`EXTERNAL_ISSUE_${error.code}`, `[${sourceAndKey.source}] ${error.message}`);
+                    }
+                    const message = error instanceof Error ? error.message : 'Failed to fetch external issue.';
+                    db.close();
+                    return handleError('EXTERNAL_ISSUE_REQUEST_FAILED', message);
+                }
+                if (!envelope) {
+                    db.close();
+                    return handleError('EXTERNAL_ISSUE_NOT_FOUND', `${sourceAndKey.source} issue "${sourceAndKey.key}" was not found.`);
+                }
+                const existingLinkedTicket = await this.findLinkedTicketByEnvelope(projectId, envelope);
+                let linkedTicket;
+                if (mirrorToPmo) {
+                    linkedTicket = await this.createOrUpdateLinkedTicket(projectId, envelope);
+                    await autoExportToBoard(this.pmoPath, this.storage);
+                }
+                else {
+                    if (!existingLinkedTicket) {
+                        db.close();
+                        return handleError('EXTERNAL_ISSUE_NOT_MIRRORED', `No linked PMO ticket found for ${sourceAndKey.source} issue "${sourceAndKey.key}". Re-run with --mirror-to-pmo.`);
+                    }
+                    linkedTicket = existingLinkedTicket;
+                }
+                ticketId = linkedTicket.id;
+                externalIssueContextMessage = buildExternalSpawnContextMessage(envelope, flags.message);
+            }
             if (!ticketId) {
                 // Get all tickets, optionally filtered by project if -P/--project flag is provided
                 const allTickets = await this.storage.listTickets(projectId);
@@ -285,6 +500,19 @@ export default class WorkStart extends PMOCommand {
                                 : earlyConfigPrDefault === false ? 'no-pr'
                                     : 'no-pr';
                     metadata.resolvedPRMode = earlyResolvedPr;
+                    const externalMetadata = getTicketExternalMetadata(ticket);
+                    if (externalMetadata.source || externalMetadata.key) {
+                        metadata.externalIssue = {
+                            source: externalMetadata.source ?? null,
+                            key: externalMetadata.key ?? null,
+                            id: externalMetadata.id ?? null,
+                            url: externalMetadata.url ?? null,
+                        };
+                    }
+                    if (flags['from-issue']) {
+                        metadata.mirrorToPmo = fromIssueMirror ?? null;
+                        metadata.mirrorToPmoSource = fromIssueMirrorSource ?? null;
+                    }
                     // Build the confirm command with --yes
                     let confirmCmd = `prlt work start ${ticketId}`;
                     if (flags.action)
@@ -796,7 +1024,7 @@ export default class WorkStart extends PMOCommand {
                 actionEndPrompt: customPrompt ? undefined : selectedAction?.endPrompt,
                 modifiesCode: customPrompt ? true : selectedAction?.modifiesCode ?? true,
                 // Additional instructions from --message flag
-                customMessage: flags.message,
+                customMessage: externalIssueContextMessage ?? flags.message,
             };
             // Check if agent has devcontainer config
             const hasDevcontainer = hasDevcontainerConfig(agentDir);
@@ -1523,6 +1751,7 @@ export default class WorkStart extends PMOCommand {
                 }
             }
             // Create execution record
+            const ticketExternalMetadata = getTicketExternalMetadata(ticket);
             const execution = executionStorage.createExecution({
                 ticketId: ticket.id,
                 agentName: assignedAgent,
@@ -1531,6 +1760,10 @@ export default class WorkStart extends PMOCommand {
                 displayMode,
                 permissionMode,
                 branch,
+                externalSource: ticketExternalMetadata.source,
+                externalKey: ticketExternalMetadata.key,
+                externalId: ticketExternalMetadata.id,
+                externalUrl: ticketExternalMetadata.url,
             });
             if (!jsonMode) {
                 this.log(styles.muted(`   Work ID: ${execution.id}`));
@@ -2027,6 +2260,7 @@ export default class WorkStart extends PMOCommand {
             }
         }
         // Create execution record
+        const ticketExternalMetadata = getTicketExternalMetadata(ticket);
         const execution = executionStorage.createExecution({
             ticketId: ticket.id,
             agentName,
@@ -2035,6 +2269,10 @@ export default class WorkStart extends PMOCommand {
             displayMode,
             permissionMode,
             branch,
+            externalSource: ticketExternalMetadata.source,
+            externalKey: ticketExternalMetadata.key,
+            externalId: ticketExternalMetadata.id,
+            externalUrl: ticketExternalMetadata.url,
         });
         // Note: Ticket status update moved to after successful spawn
         // Load execution config

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

@@ -0,0 +1,15 @@
+import type { AsanaProject, AsanaTask, AsanaTaskUpsertInput, AsanaUser, AsanaWorkspace } from './types.js';
+export declare class AsanaClient {
+    private accessToken;
+    private readonly baseUrl;
+    constructor(accessToken: string);
+    private request;
+    verify(): Promise<AsanaUser>;
+    listWorkspaces(): Promise<AsanaWorkspace[]>;
+    getWorkspace(workspaceGid: string): Promise<AsanaWorkspace | null>;
+    listProjects(workspaceGid: string): Promise<AsanaProject[]>;
+    getProject(projectGid: string): Promise<AsanaProject | null>;
+    getTask(taskGid: string): Promise<AsanaTask | null>;
+    createTask(input: AsanaTaskUpsertInput): Promise<AsanaTask>;
+    updateTask(taskGid: string, input: AsanaTaskUpsertInput): Promise<AsanaTask>;
+}

package/dist/lib/asana/client.js

@@ -0,0 +1,120 @@
+export class AsanaClient {
+    accessToken;
+    baseUrl = 'https://app.asana.com/api/1.0';
+    constructor(accessToken) {
+        this.accessToken = accessToken;
+    }
+    async request(path, init = {}) {
+        const url = new URL(`${this.baseUrl}${path}`);
+        if (init.query) {
+            for (const [key, value] of Object.entries(init.query)) {
+                if (value !== undefined) {
+                    url.searchParams.set(key, String(value));
+                }
+            }
+        }
+        // eslint-disable-next-line n/no-unsupported-features/node-builtins -- fetch is available in supported Node runtimes for this CLI
+        const response = await fetch(url, {
+            method: init.method ?? 'GET',
+            headers: {
+                Authorization: `Bearer ${this.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: init.body ? JSON.stringify(init.body) : undefined,
+        });
+        const payload = await response.json();
+        if (!response.ok) {
+            const errorMessage = payload?.errors?.[0]?.message ?? `Asana API request failed (${response.status})`;
+            throw new Error(errorMessage);
+        }
+        return payload.data;
+    }
+    async verify() {
+        const user = await this.request('/users/me', {
+            query: { opt_fields: 'gid,name,email,workspaces.gid,workspaces.name' },
+        });
+        return {
+            gid: user.gid,
+            name: user.name,
+            email: user.email,
+            workspaces: (user.workspaces ?? []).map((workspace) => ({
+                gid: workspace.gid,
+                name: workspace.name,
+            })),
+        };
+    }
+    async listWorkspaces() {
+        const user = await this.verify();
+        return user.workspaces;
+    }
+    async getWorkspace(workspaceGid) {
+        try {
+            const workspace = await this.request(`/workspaces/${workspaceGid}`);
+            return { gid: workspace.gid, name: workspace.name };
+        }
+        catch {
+            return null;
+        }
+    }
+    async listProjects(workspaceGid) {
+        const projects = await this.request('/projects', {
+            query: {
+                workspace: workspaceGid,
+                archived: false,
+                opt_fields: 'gid,name',
+            },
+        });
+        return projects.map((project) => ({ gid: project.gid, name: project.name }));
+    }
+    async getProject(projectGid) {
+        try {
+            const project = await this.request(`/projects/${projectGid}`, {
+                query: { opt_fields: 'gid,name' },
+            });
+            return { gid: project.gid, name: project.name };
+        }
+        catch {
+            return null;
+        }
+    }
+    async getTask(taskGid) {
+        try {
+            const task = await this.request(`/tasks/${taskGid}`, {
+                query: { opt_fields: 'gid,name,completed,notes' },
+            });
+            return {
+                gid: task.gid,
+                name: task.name,
+                completed: task.completed,
+                notes: task.notes,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async createTask(input) {
+        const task = await this.request('/tasks', {
+            method: 'POST',
+            body: { data: input },
+        });
+        return {
+            gid: task.gid,
+            name: task.name,
+            completed: task.completed,
+            notes: task.notes,
+        };
+    }
+    async updateTask(taskGid, input) {
+        const task = await this.request(`/tasks/${taskGid}`, {
+            method: 'PUT',
+            body: { data: input },
+        });
+        return {
+            gid: task.gid,
+            name: task.name,
+            completed: task.completed,
+            notes: task.notes,
+        };
+    }
+}

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

@@ -0,0 +1,9 @@
+import Database from 'better-sqlite3';
+import type { AsanaConfig } from './types.js';
+export declare function isAsanaConfigured(db: Database.Database): boolean;
+export declare function loadAsanaConfig(db: Database.Database): AsanaConfig | null;
+export declare function saveAsanaAccessToken(db: Database.Database, accessToken: string): void;
+export declare function saveAsanaWorkspace(db: Database.Database, workspaceGid: string, workspaceName: string): void;
+export declare function saveAsanaProject(db: Database.Database, projectGid: string, projectName: string): void;
+export declare function clearAsanaConfig(db: Database.Database): void;
+export declare function getAsanaAccessToken(db: Database.Database): string | null;

package/dist/lib/asana/config.js

@@ -0,0 +1,61 @@
+const SETTINGS_TABLE = 'workspace_settings';
+const ASANA_CONFIG_KEYS = {
+    accessToken: 'asana.access_token',
+    workspaceGid: 'asana.workspace_gid',
+    workspaceName: 'asana.workspace_name',
+    projectGid: 'asana.project_gid',
+    projectName: 'asana.project_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 isAsanaConfigured(db) {
+    return getSetting(db, ASANA_CONFIG_KEYS.accessToken) !== null;
+}
+export function loadAsanaConfig(db) {
+    const accessToken = getSetting(db, ASANA_CONFIG_KEYS.accessToken);
+    if (!accessToken)
+        return null;
+    return {
+        accessToken,
+        workspaceGid: getSetting(db, ASANA_CONFIG_KEYS.workspaceGid) ?? undefined,
+        workspaceName: getSetting(db, ASANA_CONFIG_KEYS.workspaceName) ?? undefined,
+        projectGid: getSetting(db, ASANA_CONFIG_KEYS.projectGid) ?? undefined,
+        projectName: getSetting(db, ASANA_CONFIG_KEYS.projectName) ?? undefined,
+    };
+}
+export function saveAsanaAccessToken(db, accessToken) {
+    setSetting(db, ASANA_CONFIG_KEYS.accessToken, accessToken);
+}
+export function saveAsanaWorkspace(db, workspaceGid, workspaceName) {
+    setSetting(db, ASANA_CONFIG_KEYS.workspaceGid, workspaceGid);
+    setSetting(db, ASANA_CONFIG_KEYS.workspaceName, workspaceName);
+}
+export function saveAsanaProject(db, projectGid, projectName) {
+    setSetting(db, ASANA_CONFIG_KEYS.projectGid, projectGid);
+    setSetting(db, ASANA_CONFIG_KEYS.projectName, projectName);
+}
+export function clearAsanaConfig(db) {
+    for (const key of Object.values(ASANA_CONFIG_KEYS)) {
+        deleteSetting(db, key);
+    }
+}
+export function getAsanaAccessToken(db) {
+    const envToken = process.env.PRLT_ASANA_ACCESS_TOKEN || process.env.ASANA_ACCESS_TOKEN;
+    if (envToken)
+        return envToken;
+    return getSetting(db, ASANA_CONFIG_KEYS.accessToken);
+}

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

@@ -0,0 +1,5 @@
+export { AsanaClient } from './client.js';
+export { isAsanaConfigured, loadAsanaConfig, saveAsanaAccessToken, saveAsanaWorkspace, saveAsanaProject, clearAsanaConfig, getAsanaAccessToken, } from './config.js';
+export { AsanaMapper } from './mapper.js';
+export { AsanaSync } from './sync.js';
+export type { AsanaConfig, AsanaWorkspace, AsanaProject, AsanaUser, AsanaTask, AsanaTaskMap, AsanaTaskUpsertInput, } from './types.js';

package/dist/lib/asana/index.js

@@ -0,0 +1,4 @@
+export { AsanaClient } from './client.js';
+export { isAsanaConfigured, loadAsanaConfig, saveAsanaAccessToken, saveAsanaWorkspace, saveAsanaProject, clearAsanaConfig, getAsanaAccessToken, } from './config.js';
+export { AsanaMapper } from './mapper.js';
+export { AsanaSync } from './sync.js';

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

@@ -0,0 +1,13 @@
+import Database from 'better-sqlite3';
+import type { AsanaTaskMap } from './types.js';
+export declare class AsanaMapper {
+    private db;
+    constructor(db: Database.Database);
+    private ensureTable;
+    createOrUpdateMapping(pmoTicketId: string, asanaTaskGid: string, asanaProjectGid?: string): void;
+    getByTicketId(ticketId: string): AsanaTaskMap | null;
+    getByTaskGid(asanaTaskGid: string): AsanaTaskMap | null;
+    listMappings(): AsanaTaskMap[];
+    updateSyncTimestamp(ticketId: string): void;
+    private rowToMap;
+}

package/dist/lib/asana/mapper.js

@@ -0,0 +1,70 @@
+import { PMO_TABLES } from '../pmo/schema.js';
+export class AsanaMapper {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.ensureTable();
+    }
+    ensureTable() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${PMO_TABLES.asana_task_map} (
+        pmo_ticket_id TEXT NOT NULL REFERENCES ${PMO_TABLES.tickets}(id) ON DELETE CASCADE,
+        asana_task_gid TEXT NOT NULL,
+        asana_project_gid TEXT,
+        last_synced_at TIMESTAMP,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (pmo_ticket_id),
+        UNIQUE (asana_task_gid)
+      )
+    `);
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_pmo_asana_task_map_task_gid
+        ON ${PMO_TABLES.asana_task_map}(asana_task_gid)
+    `);
+    }
+    createOrUpdateMapping(pmoTicketId, asanaTaskGid, asanaProjectGid) {
+        this.db.prepare(`
+      INSERT INTO ${PMO_TABLES.asana_task_map}
+        (pmo_ticket_id, asana_task_gid, asana_project_gid, last_synced_at, created_at)
+      VALUES (?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+      ON CONFLICT(pmo_ticket_id) DO UPDATE SET
+        asana_task_gid = excluded.asana_task_gid,
+        asana_project_gid = excluded.asana_project_gid,
+        last_synced_at = CURRENT_TIMESTAMP
+    `).run(pmoTicketId, asanaTaskGid, asanaProjectGid ?? null);
+    }
+    getByTicketId(ticketId) {
+        const row = this.db.prepare(`
+      SELECT * FROM ${PMO_TABLES.asana_task_map} WHERE pmo_ticket_id = ?
+    `).get(ticketId);
+        return row ? this.rowToMap(row) : null;
+    }
+    getByTaskGid(asanaTaskGid) {
+        const row = this.db.prepare(`
+      SELECT * FROM ${PMO_TABLES.asana_task_map} WHERE asana_task_gid = ?
+    `).get(asanaTaskGid);
+        return row ? this.rowToMap(row) : null;
+    }
+    listMappings() {
+        const rows = this.db.prepare(`
+      SELECT * FROM ${PMO_TABLES.asana_task_map} ORDER BY created_at DESC
+    `).all();
+        return rows.map((row) => this.rowToMap(row));
+    }
+    updateSyncTimestamp(ticketId) {
+        this.db.prepare(`
+      UPDATE ${PMO_TABLES.asana_task_map}
+      SET last_synced_at = CURRENT_TIMESTAMP
+      WHERE pmo_ticket_id = ?
+    `).run(ticketId);
+    }
+    rowToMap(row) {
+        return {
+            pmoTicketId: row.pmo_ticket_id,
+            asanaTaskGid: row.asana_task_gid,
+            asanaProjectGid: row.asana_project_gid ?? undefined,
+            lastSyncedAt: row.last_synced_at ? new Date(row.last_synced_at) : undefined,
+            createdAt: new Date(row.created_at),
+        };
+    }
+}

package/dist/lib/asana/sync.d.ts

@@ -0,0 +1,13 @@
+import type { Ticket } from '../pmo/types.js';
+import { AsanaClient } from './client.js';
+import { AsanaMapper } from './mapper.js';
+export declare class AsanaSync {
+    private client;
+    private mapper;
+    constructor(client: AsanaClient, mapper: AsanaMapper);
+    private buildTaskName;
+    private buildTaskNotes;
+    private isCompletedStatus;
+    createTaskForTicket(ticket: Ticket, projectGid: string): Promise<string>;
+    syncTicket(ticket: Ticket, taskGid: string): Promise<void>;
+}