@doist/doistbot-cli 1.0.5 → 1.0.7

package/sandbox/dist/core/prompt-template.js

@@ -1,15 +1,57 @@
 import fs from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
 import { logger } from './logging.js';
+const promptCache = new Map();
+const resolveCache = new Map();
+/** Swap the `dist` directory nearest to the file (not just the first `/dist/` in the path) for `src`. */
+function distDirToSrcDir(dir) {
+    const distSeg = `${path.sep}dist${path.sep}`;
+    const idx = dir.lastIndexOf(distSeg);
+    if (idx === -1) {
+        return dir;
+    }
+    return `${dir.slice(0, idx)}${path.sep}src${path.sep}${dir.slice(idx + distSeg.length)}`;
+}
+/**
+ * Resolve a prompt file living in `<module>/prompts/`, relative to the calling
+ * module. At runtime the module lives under `dist/`, but the prompts are shipped
+ * under `src/`, so we map `dist`->`src`. The `dist` candidate is tried first so a
+ * future build step that copies prompts into `dist/` works without code changes.
+ */
+export function resolvePromptFile(moduleUrl, fileName) {
+    const byFileName = resolveCache.get(moduleUrl) ?? new Map();
+    resolveCache.set(moduleUrl, byFileName);
+    const cached = byFileName.get(fileName);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const dir = path.dirname(fileURLToPath(moduleUrl));
+    const candidates = [
+        path.join(dir, 'prompts', fileName),
+        path.join(distDirToSrcDir(dir), 'prompts', fileName),
+    ];
+    const resolved = candidates.find(fs.existsSync) ?? candidates[candidates.length - 1];
+    byFileName.set(fileName, resolved);
+    return resolved;
+}
 export function loadPromptTemplateFile({ fileName, promptLabel, }) {
-    const promptPath = path.resolve(fileName);
+    if (!path.isAbsolute(fileName)) {
+        throw new Error(`${promptLabel} prompt template path must be absolute (resolve it with resolvePromptFile first), got: ${fileName}`);
+    }
+    const cached = promptCache.get(fileName);
+    if (cached !== undefined) {
+        return cached;
+    }
     try {
-        return fs.readFileSync(promptPath, 'utf8');
+        const contents = fs.readFileSync(fileName, 'utf8');
+        promptCache.set(fileName, contents);
+        return contents;
     }
     catch (error) {
         logger.error(`Failed to load ${promptLabel} prompt template`, {
             error: error instanceof Error ? error.message : String(error),
-            promptPath,
+            promptPath: fileName,
         });
         throw error;
     }

package/sandbox/dist/core/repository-map.js

@@ -64,6 +64,16 @@ const TODOIST_REPOSITORIES = [
         product: 'Todoist',
         surfaces: ['android', 'ios'],
     }),
+    createRepositoryTarget({
+        repo: 'todoist-mcp',
+        product: 'Todoist',
+        surfaces: ['mcp'],
+    }),
+    createRepositoryTarget({
+        repo: 'todoist-cli',
+        product: 'Todoist',
+        surfaces: ['cli'],
+    }),
 ];
 const TWIST_REPOSITORIES = [
     createRepositoryTarget({
@@ -126,6 +136,16 @@ const TWIST_REPOSITORIES = [
         product: 'Twist',
         surfaces: ['desktop'],
     }),
+    createRepositoryTarget({
+        repo: 'twist-ai',
+        product: 'Twist',
+        surfaces: ['mcp'],
+    }),
+    createRepositoryTarget({
+        repo: 'twist-cli',
+        product: 'Twist',
+        surfaces: ['cli'],
+    }),
 ];
 function dedupeRepositories(repositories) {
     const unique = new Map();
@@ -145,8 +165,10 @@ export const APP_TO_REPO_SELECTORS = {
     all: (repositories) => dedupeRepositories(repositories),
     android: (repositories) => selectBySurface(repositories, ['android']),
     backend: (repositories) => selectBySurface(repositories, ['backend']),
+    cli: (repositories) => selectBySurface(repositories, ['cli']),
     desktop: (repositories) => selectBySurface(repositories, ['desktop']),
     ios: (repositories) => selectBySurface(repositories, ['ios']),
+    mcp: (repositories) => selectBySurface(repositories, ['mcp']),
     web: (repositories) => selectBySurface(repositories, ['web']),
 };
 export const TEAM_TO_REPO_SELECTORS = {
@@ -179,8 +201,10 @@ export const APP_LABEL_ALIASES = {
     all: 'all',
     android: 'android',
     backend: 'backend',
+    cli: 'cli',
     desktop: 'desktop',
     ios: 'ios',
+    mcp: 'mcp',
     web: 'web',
 };
 export const TEAM_LABEL_ALIASES = {

package/sandbox/dist/core/tracing-setup.js

@@ -0,0 +1,15 @@
+import { context, trace } from '@opentelemetry/api';
+import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
+import { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
+import { LoggerSpanProcessor } from './logger-span-processor.js';
+let registered = false;
+export function setupTracing() {
+    if (registered)
+        return;
+    registered = true;
+    context.setGlobalContextManager(new AsyncLocalStorageContextManager());
+    const provider = new BasicTracerProvider({
+        spanProcessors: [new LoggerSpanProcessor()],
+    });
+    trace.setGlobalTracerProvider(provider);
+}

package/sandbox/dist/core/tracing.js

@@ -0,0 +1,80 @@
+import { context, SpanStatusCode, trace } from '@opentelemetry/api';
+// recordDecision/recordEvent emit directly (bypassing the processor), so they
+// apply the same per-attribute cap themselves to keep large arrays/objects
+// from blowing the log-size budget.
+import { truncateAttrs } from './logger-span-processor.js';
+import { logger } from './logging.js';
+const tracer = trace.getTracer('doistbot-sandbox');
+/**
+ * THE phase-boundary API. Works for sequential AND parallel phases — OTel's
+ * async-hooks context manager (registered by setupTracing) parents nested
+ * spans correctly even across Promise.all.
+ *
+ * On throw: records the exception, sets span status ERROR, re-throws.
+ * On normal return: status is left UNSET (OTel's recommended success default;
+ *   the LoggerSpanProcessor maps UNSET → 'ok'). We deliberately do NOT force
+ *   OK, so a callback that returns a failure result (instead of throwing) and
+ *   sets ERROR itself keeps its ERROR status.
+ * Always ends the span.
+ */
+export async function withPhase(name, attributes, fn) {
+    return tracer.startActiveSpan(name, { attributes: { ...attributes, 'doistbot.kind': 'phase' } }, async (span) => {
+        try {
+            return await fn(span);
+        }
+        catch (err) {
+            span.recordException(err);
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    });
+}
+/**
+ * Start a tool span manually. The ONE exception to "withPhase everywhere":
+ * pi emits tool start/end across separate async callbacks (onProgress), so
+ * there is no single scope to wrap. Parent = the currently-active span (the
+ * model phase). Caller MUST call `span.end()` when the matching tool_end
+ * arrives (and may `setStatus({ code: ERROR })` first on failure).
+ */
+export function startToolSpan(name, attributes) {
+    return tracer.startSpan(name, { attributes: { ...attributes, 'doistbot.kind': 'tool' } }, context.active());
+}
+// Point-in-time lines bypass OTel spans entirely; they read the active span
+// id only for correlation. Meta is spread FIRST so callers can never clobber
+// the envelope fields (event/name/span_id). Timestamps come from the logging
+// system, never from meta.
+function emitPointInTime(kind, name, meta) {
+    const span = trace.getActiveSpan();
+    logger.info(`${kind}: ${name}`, {
+        ...truncateAttrs(meta),
+        event: kind,
+        name,
+        span_id: span?.spanContext().spanId ?? null,
+    });
+}
+/**
+ * Record a point-in-time decision (branch taken, scope resolved, gate passed)
+ * correlated to the active span. Not a span — no duration.
+ */
+export function recordDecision(name, meta) {
+    emitPointInTime('decision', name, meta);
+}
+/** Generic point-in-time annotation. Same mechanics as recordDecision. */
+export function recordEvent(name, meta) {
+    emitPointInTime('event', name, meta);
+}
+/**
+ * Maps a doistbot provider key to the OTel `gen_ai.provider.name` value
+ * (docs/sandbox-instrumentation.md). Only `gemini` has a standard name
+ * (`gcp.gemini`); the OpenRouter-routed keys (`zai`, `deepseek`) have none, so
+ * they pass through. Single source so every span site stays consistent.
+ */
+export function genAiProviderName(provider) {
+    return provider === 'gemini' ? 'gcp.gemini' : provider;
+}

package/sandbox/dist/main.js

@@ -1,3 +1,7 @@
+import { setupTracing } from './core/tracing-setup.js';
+// Register the OTel SDK before any task module loads — withPhase/startToolSpan
+// are no-ops until a tracer provider is registered.
+setupTracing();
 const taskType = process.env.TASK_TYPE ?? 'review';
 switch (taskType) {
     case 'chat':
@@ -32,4 +36,3 @@ switch (taskType) {
         process.stderr.write(`Unknown TASK_TYPE: ${taskType}\n`);
         process.exit(1);
 }
-export {};

package/sandbox/dist/providers/credentials.js

@@ -1,7 +1,15 @@
+import { parsePiAuthProviderId } from '../core/pi.js';
 export function resolveReviewProviderCredential(credential) {
     if (typeof credential === 'string') {
         const apiKey = credential.trim();
-        return apiKey ? { apiKey } : undefined;
+        if (!apiKey) {
+            return undefined;
+        }
+        const piAuthProviderId = parsePiAuthProviderId(apiKey);
+        return {
+            apiKey,
+            ...(piAuthProviderId ? { piProviderId: piAuthProviderId } : {}),
+        };
     }
     if (!credential) {
         return undefined;
@@ -10,9 +18,11 @@ export function resolveReviewProviderCredential(credential) {
     if (!apiKey) {
         return undefined;
     }
+    const piAuthProviderId = parsePiAuthProviderId(apiKey);
+    const piProviderId = piAuthProviderId ?? credential.piProviderId;
     return {
         apiKey,
-        ...(credential.piProviderId ? { piProviderId: credential.piProviderId } : {}),
+        ...(piProviderId ? { piProviderId } : {}),
         ...(credential.modelName ? { modelName: credential.modelName } : {}),
     };
 }

package/sandbox/dist/providers/gemini.js

@@ -9,7 +9,11 @@ import { runPiReviewProvider } from './pi-review.js';
 export class GeminiProvider {
     name = 'gemini';
     async review(prompt, config) {
-        const modelName = config.modelName ?? DEFAULT_OPENROUTER_MODELS.gemini ?? DEFAULT_PI_MODELS.gemini;
+        const modelName = config.modelName ??
+            (config.piProviderId === 'openrouter'
+                ? DEFAULT_OPENROUTER_MODELS.gemini
+                : DEFAULT_PI_MODELS.gemini) ??
+            DEFAULT_PI_MODELS.gemini;
         return await runPiReviewProvider({
             provider: this.name,
             modelName,

package/sandbox/dist/providers/helpers.js

@@ -6,6 +6,57 @@ import { logger } from '../core/logging.js';
 import { isRawReviewResult } from './schemas.js';
 const RAW_MODEL_LOG_CHUNK_CHARS = 8000;
 const REVIEW_LOG_ENGINE = 'multi_focus';
+const PROVIDER_ERROR_DETAILS_MAX_DEPTH = 8;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseJsonValue(value) {
+    try {
+        return JSON.parse(value.trim());
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readProviderErrorDetails(error) {
+    const rawError = error instanceof Error ? error.message : String(error);
+    const details = { rawError };
+    function visit(value, depth) {
+        if (depth > PROVIDER_ERROR_DETAILS_MAX_DEPTH) {
+            return;
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            const parsed = parseJsonValue(trimmed);
+            if (isRecord(parsed)) {
+                visit(parsed, depth + 1);
+                return;
+            }
+            if (!details.reason && trimmed) {
+                details.reason = trimmed;
+            }
+            return;
+        }
+        if (!isRecord(value)) {
+            return;
+        }
+        if (value.error !== undefined) {
+            visit(value.error, depth + 1);
+        }
+        if (typeof value.message === 'string') {
+            visit(value.message, depth + 1);
+        }
+        if (details.errorCode === undefined &&
+            (typeof value.code === 'number' || typeof value.code === 'string')) {
+            details.errorCode = value.code;
+        }
+        if (details.status === undefined && typeof value.status === 'string') {
+            details.status = value.status;
+        }
+    }
+    visit(rawError, 0);
+    return details;
+}
 function redactSensitiveStrings(content) {
     return content
         .replace(/(sk-[A-Za-z0-9_-]{10,})/g, '[REDACTED_OPENAI_KEY]')
@@ -166,29 +217,24 @@ function extractBalancedJsonCandidates(content) {
     }
     return candidates;
 }
+/**
+ * Returns JSON-looking candidates from a response string in parser preference order.
+ * Fenced JSON blocks are preferred over balanced objects because models often include
+ * code snippets or object-shaped prose before the final fenced response.
+ */
+export function extractJsonCandidatesFromResponse(content) {
+    return [
+        ...extractFencedJsonCandidates(content).reverse(),
+        ...extractBalancedJsonCandidates(content).reverse(),
+    ];
+}
 /**
  * Extracts JSON from a response string that may contain additional text.
  * Prefers valid fenced JSON blocks, then valid balanced JSON objects.
  * Throws when no valid JSON candidate can be parsed.
  */
 export function extractJsonFromResponse(content) {
-    const fencedCandidates = extractFencedJsonCandidates(content);
-    for (let index = fencedCandidates.length - 1; index >= 0; index--) {
-        const candidate = fencedCandidates[index];
-        if (!candidate) {
-            continue;
-        }
-        try {
-            JSON.parse(candidate);
-            return candidate;
-        }
-        catch {
-            continue;
-        }
-    }
-    const balancedCandidates = extractBalancedJsonCandidates(content);
-    for (let index = balancedCandidates.length - 1; index >= 0; index--) {
-        const candidate = balancedCandidates[index];
+    for (const candidate of extractJsonCandidatesFromResponse(content)) {
         if (!candidate) {
             continue;
         }

package/sandbox/dist/providers/index.js

@@ -3,11 +3,15 @@
  */
 import { GeminiProvider } from './gemini.js';
 import { OpenAIProvider } from './openai.js';
+import { OpenRouterPiProvider } from './openrouter-pi.js';
 export { GeminiProvider } from './gemini.js';
 export { OpenAIProvider } from './openai.js';
+export { OpenRouterPiProvider } from './openrouter-pi.js';
 export * from './types.js';
 const providers = {
+    deepseek: new OpenRouterPiProvider('deepseek'),
     gemini: new GeminiProvider(),
+    zai: new OpenRouterPiProvider('zai'),
     openai: new OpenAIProvider(),
 };
 /**

package/sandbox/dist/providers/openrouter-pi.js

@@ -0,0 +1,25 @@
+import { DEFAULT_OPENROUTER_MODELS, DEFAULT_PI_MODELS } from '../core/pi.js';
+import { resolveProviderTimeoutMs } from './config.js';
+import { extractJsonFromResponse } from './helpers.js';
+import { runPiReviewProvider } from './pi-review.js';
+export class OpenRouterPiProvider {
+    name;
+    fallbackModelName;
+    constructor(name, fallbackModelName = DEFAULT_OPENROUTER_MODELS[name] ??
+        DEFAULT_PI_MODELS[name]) {
+        this.name = name;
+        this.fallbackModelName = fallbackModelName;
+    }
+    async review(prompt, config) {
+        return await runPiReviewProvider({
+            provider: this.name,
+            modelName: config.modelName ?? this.fallbackModelName,
+            prompt,
+            config: {
+                ...config,
+                timeout: resolveProviderTimeoutMs(config.timeout),
+            },
+            parseOutput: (output) => JSON.parse(extractJsonFromResponse(output)),
+        });
+    }
+}

package/sandbox/dist/providers/pi-review.js

@@ -1,5 +1,5 @@
 import { logger } from '../core/logging.js';
-import { createPiInvoker } from '../core/pi.js';
+import { createPiInvoker, parsePiAuthProviderId, PI_PROVIDER_BY_DOISTBOT_PROVIDER, } from '../core/pi.js';
 import { logPiProgressEvent } from '../core/pi-progress-logging.js';
 import { WORKSPACE_DIR } from '../core/shared.js';
 import { logRawModelOutput, normalizeParsedModelOutput } from './helpers.js';
@@ -47,7 +47,19 @@ function logReviewRawModelOutput(args) {
     }
     logRawModelOutput(args);
 }
-export async function runPiReviewProvider({ provider, modelName, prompt, config, prompts = [prompt], parseOutput, }) {
+function isOpenRouterBackedReviewRequest(provider, config) {
+    const resolvedPiProviderId = parsePiAuthProviderId(config.apiKey) ??
+        config.piProviderId ??
+        PI_PROVIDER_BY_DOISTBOT_PROVIDER[provider];
+    return resolvedPiProviderId === 'openrouter';
+}
+export async function runPiReviewProvider(params) {
+    // Stamp the resolved model spec on every result (success or failure) so
+    // telemetry has the real model without re-deriving each provider's default.
+    const result = await runPiReviewProviderCore(params);
+    return { ...result, requestModel: params.modelName };
+}
+async function runPiReviewProviderCore({ provider, modelName, prompt, config, prompts = [prompt], parseOutput, }) {
     const startTime = Date.now();
     const timeoutMs = config.timeout ?? 0;
     let stdout = '';
@@ -59,6 +71,9 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
         promptLength: prompt.length,
         modelName,
         timeoutMs,
+        ...(isOpenRouterBackedReviewRequest(provider, config) && config.openRouterSessionId
+            ? { openRouterSessionId: config.openRouterSessionId }
+            : {}),
     });
     try {
         const invoker = createPiInvoker({
@@ -72,6 +87,8 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
             capabilityPreset: 'read-only',
             thinkingLevel: config.thinkingLevel,
             systemPrompt: REVIEW_PI_SYSTEM_PROMPT,
+            noContextFiles: true,
+            openRouterSessionId: config.openRouterSessionId,
         });
         for (let attempt = 0; attempt < prompts.length; attempt += 1) {
             const result = await invoker.invoke({