@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/issue-triage/types.js

@@ -0,0 +1 @@
+export {};

package/sandbox/dist/tasks/persist-logs/context.js

@@ -0,0 +1,19 @@
+import { optionalPositiveInt, requiredEnv, requiredPositiveInt } from '../../core/environment.js';
+export function parsePersistLogsContext(env = process.env) {
+    return {
+        owner: requiredEnv('REPO_OWNER', env),
+        repo: requiredEnv('REPO_NAME', env),
+        issueNumber: requiredPositiveInt('ISSUE_NUMBER', env),
+        installationId: requiredPositiveInt('INSTALLATION_ID', env),
+        appId: requiredEnv('APP_ID', env),
+        privateKey: requiredEnv('PRIVATE_KEY', env),
+        datadogApiKey: requiredEnv('DATADOG_API_KEY', env),
+        datadogAppKey: requiredEnv('DATADOG_APP_KEY', env),
+        openaiApiKey: requiredEnv('OPENAI_KEY', env),
+        logSnapshotBucket: env.LOG_SNAPSHOT_BUCKET?.trim() || '',
+        dryRun: env.DRY_RUN?.toLowerCase() === 'true',
+        commentId: optionalPositiveInt(env.COMMENT_ID),
+        reactionId: optionalPositiveInt(env.REACTION_ID),
+        deliveryId: env.DELIVERY_ID?.trim() || 'unknown',
+    };
+}

package/sandbox/dist/tasks/persist-logs/dd-proxy.js

@@ -0,0 +1,116 @@
+import http from 'http';
+import https from 'https';
+import { logger } from '../../core/logging.js';
+import { scrubPii, scrubPiiFromObject } from '../../core/pii-scrubber.js';
+const DD_HOST = 'api.datadoghq.com';
+/**
+ * Starts a localhost HTTP proxy that forwards requests to the Datadog API,
+ * scrubs PII from responses, and logs each query for auditability.
+ *
+ * The agent hits http://localhost:{port}/api/v2/... instead of the DD API directly.
+ * The proxy injects DD auth headers so the agent never sees the API keys.
+ */
+export function startDdProxy({ port, datadogApiKey, datadogAppKey }) {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            const body = [];
+            req.on('data', (chunk) => body.push(chunk));
+            req.on('end', () => {
+                const requestBody = Buffer.concat(body).toString();
+                const urlPath = req.url ?? '/';
+                // Log the query for audit trail (queries contain no PII)
+                let queryString = '';
+                try {
+                    const parsed = JSON.parse(requestBody);
+                    queryString = parsed?.filter?.query ?? '';
+                }
+                catch {
+                    // Not JSON or no query field — that's fine
+                }
+                logger.info('DD proxy: forwarding query', {
+                    task: 'persist-logs',
+                    path: urlPath,
+                    method: req.method,
+                    query: scrubPii(queryString),
+                });
+                const options = {
+                    hostname: DD_HOST,
+                    port: 443,
+                    path: urlPath,
+                    method: req.method ?? 'GET',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'DD-API-KEY': datadogApiKey,
+                        'DD-APPLICATION-KEY': datadogAppKey,
+                    },
+                };
+                const proxyReq = https.request(options, (proxyRes) => {
+                    const chunks = [];
+                    proxyRes.on('error', (err) => {
+                        logger.error('DD proxy: upstream response error', {
+                            task: 'persist-logs',
+                            error: err.message,
+                            path: urlPath,
+                        });
+                        if (!res.headersSent) {
+                            res.writeHead(502);
+                            res.end(JSON.stringify({ error: 'DD proxy upstream response error' }));
+                        }
+                    });
+                    proxyRes.on('data', (chunk) => chunks.push(chunk));
+                    proxyRes.on('end', () => {
+                        const rawResponse = Buffer.concat(chunks).toString();
+                        let scrubbedResponse;
+                        try {
+                            const parsed = JSON.parse(rawResponse);
+                            const scrubbed = scrubPiiFromObject(parsed);
+                            scrubbedResponse = JSON.stringify(scrubbed);
+                        }
+                        catch {
+                            // Non-JSON response — scrub as plain text
+                            scrubbedResponse = scrubPii(rawResponse);
+                        }
+                        logger.info('DD proxy: response scrubbed', {
+                            task: 'persist-logs',
+                            path: urlPath,
+                            statusCode: proxyRes.statusCode,
+                            originalBytes: rawResponse.length,
+                            scrubbedBytes: scrubbedResponse.length,
+                        });
+                        res.writeHead(proxyRes.statusCode ?? 200, {
+                            'Content-Type': proxyRes.headers['content-type'] ?? 'application/json',
+                        });
+                        res.end(scrubbedResponse);
+                    });
+                });
+                proxyReq.on('error', (err) => {
+                    logger.error('DD proxy: upstream request failed', {
+                        task: 'persist-logs',
+                        error: err.message,
+                        path: urlPath,
+                    });
+                    res.writeHead(502);
+                    res.end(JSON.stringify({ error: 'DD proxy upstream error' }));
+                });
+                if (requestBody) {
+                    proxyReq.write(requestBody);
+                }
+                proxyReq.end();
+            });
+        });
+        server.on('error', reject);
+        server.listen(port, '127.0.0.1', () => {
+            logger.info('DD proxy started', {
+                task: 'persist-logs',
+                port,
+                target: DD_HOST,
+            });
+            resolve({
+                server,
+                stop: () => new Promise((resolveStop) => {
+                    server.close(() => resolveStop());
+                }),
+            });
+        });
+    });
+}

package/sandbox/dist/tasks/persist-logs/llm-query-planner.js

@@ -0,0 +1,156 @@
+import fs from 'fs';
+import path from 'path';
+import { logger } from '../../core/logging.js';
+import { invokePiPrompt } from '../../core/pi.js';
+import { scrubPii } from '../../core/pii-scrubber.js';
+import { loadPromptTemplateFile, resolvePromptFile } from '../../core/prompt-template.js';
+import { startDdProxy } from './dd-proxy.js';
+export const PERSIST_LOGS_PROVIDER = 'openai';
+const TIMEOUT_MS = 20 * 60 * 1000; // 20 minutes — investigation can take a while
+function buildPrompt(params, proxyPort) {
+    const ddApiReference = loadPromptTemplateFile({
+        fileName: resolvePromptFile(import.meta.url, 'persist-logs-dd-api-reference.md'),
+        promptLabel: 'persist-logs DD API reference',
+    });
+    const template = loadPromptTemplateFile({
+        fileName: resolvePromptFile(import.meta.url, 'persist-logs-investigation-prompt.md'),
+        promptLabel: 'persist-logs investigation prompt',
+    });
+    const scrubbedTitle = scrubPii(params.issueTitle);
+    const scrubbedBody = scrubPii(params.issueBody);
+    const scrubbedComments = params.comments
+        .map((c) => `### Comment by ${c.author}\n${scrubPii(c.body)}`)
+        .join('\n\n');
+    const proxyUrl = `http://127.0.0.1:${proxyPort}`;
+    const replacements = {
+        '{{PROXY_URL}}': proxyUrl,
+        '{{DD_API_REFERENCE}}': ddApiReference,
+        '{{REPO_DIR}}': params.repoDir,
+        '{{OUTPUT_DIR}}': params.outputDir,
+        '{{ISSUE_NUMBER}}': String(params.issueNumber),
+        '{{ISSUE_TITLE}}': scrubbedTitle,
+        '{{ISSUE_TITLE_ESCAPED}}': scrubbedTitle.replace(/"/g, '\\"'),
+        '{{ISSUE_BODY}}': scrubbedBody,
+        '{{COMMENTS_SECTION}}': scrubbedComments ? `## Comments\n\n${scrubbedComments}` : '',
+    };
+    let prompt = template;
+    for (const [placeholder, value] of Object.entries(replacements)) {
+        prompt = prompt.replaceAll(placeholder, value);
+    }
+    return prompt;
+}
+export async function runInvestigation(params) {
+    const DD_PROXY_PORT = 3100;
+    logger.info('Starting LLM investigation', {
+        task: 'persist-logs',
+        issueNumber: params.issueNumber,
+        repoDir: params.repoDir,
+        model: PERSIST_LOGS_PROVIDER,
+    });
+    // Ensure output directory exists
+    fs.mkdirSync(params.outputDir, { recursive: true });
+    // Start the DD proxy so the agent queries localhost; the proxy injects auth and scrubs PII.
+    const proxy = await startDdProxy({
+        port: DD_PROXY_PORT,
+        datadogApiKey: params.datadogApiKey,
+        datadogAppKey: params.datadogAppKey,
+    });
+    const prompt = buildPrompt(params, DD_PROXY_PORT);
+    let result;
+    try {
+        result = await invokePiPrompt({
+            provider: PERSIST_LOGS_PROVIDER,
+            apiKey: params.openaiApiKey,
+            prompt,
+            cwd: params.repoDir,
+            timeoutMs: TIMEOUT_MS,
+            capabilityPreset: 'shell-focused',
+            thinkingLevel: 'high',
+            onProgress: (event) => {
+                if (event.type === 'tool_start') {
+                    logger.info('Investigation tool call', {
+                        task: 'persist-logs',
+                        tool: event.toolName,
+                    });
+                }
+            },
+        });
+    }
+    finally {
+        await proxy.stop();
+        logger.info('DD proxy stopped', { task: 'persist-logs' });
+    }
+    logger.info('Persist logs invocation result', {
+        task: 'persist-logs',
+        ok: result.ok,
+        toolUsage: result.toolUsage,
+        ...(result.ok
+            ? { outputLength: result.output.length }
+            : { error: result.error, timedOut: result.timedOut }),
+    });
+    if (!result.ok) {
+        if (result.timedOut) {
+            logger.error('LLM investigation timed out', {
+                task: 'persist-logs',
+                timeoutMs: TIMEOUT_MS,
+            });
+            return {
+                success: false,
+                totalLogs: 0,
+                error: `Investigation timed out after ${TIMEOUT_MS / 1000}s`,
+            };
+        }
+        logger.error('LLM investigation failed', {
+            task: 'persist-logs',
+            error: result.error,
+        });
+        return { success: false, totalLogs: 0, error: result.error };
+    }
+    // Check for output files
+    const rawLogsPath = path.join(params.outputDir, `raw-logs-${params.issueNumber}.json`);
+    const analysisPath = path.join(params.outputDir, `analysis-${params.issueNumber}.md`);
+    const csvPath = path.join(params.outputDir, `logs-${params.issueNumber}.csv`);
+    const worklogPath = path.join(params.outputDir, `worklog-${params.issueNumber}.md`);
+    const hasRawLogs = fs.existsSync(rawLogsPath);
+    const hasAnalysis = fs.existsSync(analysisPath);
+    const hasCsv = fs.existsSync(csvPath);
+    const hasWorklog = fs.existsSync(worklogPath);
+    let totalLogs = 0;
+    if (hasRawLogs) {
+        try {
+            const raw = JSON.parse(fs.readFileSync(rawLogsPath, 'utf-8'));
+            totalLogs = raw.total_log_entries ?? 0;
+        }
+        catch {
+            logger.warn('Could not parse raw logs file', {
+                task: 'persist-logs',
+                path: rawLogsPath,
+            });
+        }
+    }
+    if (!hasRawLogs) {
+        logger.warn('LLM investigation completed but raw-logs JSON not generated', {
+            task: 'persist-logs',
+            outputDir: params.outputDir,
+            hasAnalysis,
+        });
+        return { success: false, totalLogs: 0, error: 'raw-logs JSON not generated' };
+    }
+    logger.info('LLM investigation completed', {
+        task: 'persist-logs',
+        totalLogs,
+        hasRawLogs,
+        hasAnalysis,
+        hasCsv,
+        hasWorklog,
+        toolUsage: result.toolUsage,
+    });
+    return {
+        success: true,
+        rawLogsPath: hasRawLogs ? rawLogsPath : undefined,
+        analysisPath: hasAnalysis ? analysisPath : undefined,
+        csvPath: hasCsv ? csvPath : undefined,
+        worklogPath: hasWorklog ? worklogPath : undefined,
+        totalLogs,
+    };
+}