@doist/doistbot-cli 1.0.12 → 1.0.14

package/sandbox/dist/tasks/issue-triage/hero-group-map.js

@@ -1,5 +1,5 @@
 import { normalizeScopedLabelValue, scopedLabelValue } from '../../core/label-parsing.js';
-import { APP_LABEL_ALIASES, findIssueRoute, findRepositoryRoutes, findRepositoryTarget as findRoutingRepositoryTarget, PRODUCT_LABEL_ALIASES, PRODUCT_ROUTES, } from '../../core/repository-map.js';
+import { APP_LABEL_ALIASES, findIntegrationRoute, findIssueRoute, findOwningRoutes, findRepositoryTarget as findRoutingRepositoryTarget, INTEGRATION_LABEL_ALIASES, PRODUCT_LABEL_ALIASES, PRODUCT_ROUTES, } from '../../core/repository-map.js';
 const HERO_GROUPS = {
     'android-hero': { key: 'android-hero', mention: '@Doist/android-hero' },
     'app-copy-hero': { key: 'app-copy-hero', mention: '@Doist/app-copy-hero' },
@@ -63,11 +63,18 @@ export function resolveHeroTeamSlug(target) {
 function resolveAppLabelAlias(value) {
     return APP_LABEL_ALIASES[normalizeScopedLabelValue(value)];
 }
+function resolveIntegrationLabelAlias(value) {
+    return INTEGRATION_LABEL_ALIASES[normalizeScopedLabelValue(value)];
+}
 export function isKnownHeroRoutingLabel(label) {
     const teamValue = scopedLabelValue(label, 'Team');
     if (teamValue && TEAM_LABEL_TO_HERO[normalizeScopedLabelValue(teamValue)]) {
         return true;
     }
+    const integrationValue = scopedLabelValue(label, 'Integration');
+    if (integrationValue && resolveIntegrationLabelAlias(integrationValue)) {
+        return true;
+    }
     const appValue = scopedLabelValue(label, 'App');
     if (!appValue) {
         return false;
@@ -91,6 +98,28 @@ function resolveProduct(labels) {
     }
     return products.size === 1 ? products.values().next().value : undefined;
 }
+function resolveIntegrationHeroKeys(labels) {
+    const product = resolveProduct(labels);
+    const heroKeys = new Set();
+    for (const label of labels) {
+        const integrationValue = scopedLabelValue(label, 'Integration');
+        if (!integrationValue) {
+            continue;
+        }
+        const integration = resolveIntegrationLabelAlias(integrationValue);
+        if (!integration) {
+            continue;
+        }
+        const route = findIntegrationRoute(integration);
+        // An integration from another product is not in scope for this issue, so
+        // it must not contribute a hero the repository resolver would never pick.
+        if (product && route.product !== product) {
+            continue;
+        }
+        heroKeys.add(route.heroTeam);
+    }
+    return heroKeys;
+}
 function resolveAppRouteHeroKeys(labels) {
     const routeIds = new Set();
     for (const label of labels) {
@@ -99,7 +128,9 @@ function resolveAppRouteHeroKeys(labels) {
             continue;
         }
         const appLabel = resolveAppLabelAlias(appValue);
-        if (appLabel && appLabel !== 'all') {
+        // `all` spans every route and `integration` names no route of its own —
+        // the accompanying `Integration:*` label supplies that hero instead.
+        if (appLabel && appLabel !== 'all' && appLabel !== 'integration') {
             routeIds.add(appLabel);
         }
     }
@@ -135,6 +166,13 @@ export function resolveHeroGroup(labels, primaryRepo) {
     if (teamHeroKeys.size > 1) {
         return null;
     }
+    const integrationHeroKeys = resolveIntegrationHeroKeys(labels);
+    if (integrationHeroKeys.size === 1) {
+        return HERO_GROUPS[integrationHeroKeys.values().next().value];
+    }
+    if (integrationHeroKeys.size > 1) {
+        return null;
+    }
     const appHeroKeys = resolveAppRouteHeroKeys(labels);
     if (appHeroKeys.size === 1) {
         return HERO_GROUPS[appHeroKeys.values().next().value];
@@ -143,7 +181,7 @@ export function resolveHeroGroup(labels, primaryRepo) {
         return null;
     }
     if (primaryRepo) {
-        const repositoryHeroKeys = new Set(findRepositoryRoutes(primaryRepo).map((route) => route.heroTeam));
+        const repositoryHeroKeys = new Set(findOwningRoutes(primaryRepo).map((route) => route.heroTeam));
         if (repositoryHeroKeys.size === 1) {
             return HERO_GROUPS[repositoryHeroKeys.values().next().value];
         }

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

@@ -1,3 +1,4 @@
 export const HERO_AUTOFIX_MARKER = '<!--doistbot-autofix-followup-->';
+export const ASSIGNEE_REVIEW_MARKER = '<!--doistbot-assignee-review-requested-->';
 export const FIX_LOOP_START_MARKER = '<!--doistbot-fixloop-start-->';
 export const AUTOFIX_FAILURE_MARKER = '<!--doistbot-autofix-failure-->';

package/sandbox/dist/tasks/issue-triage/pr-creator.js

@@ -4,6 +4,10 @@ import path from 'path';
 import { DOISTBOT_AUTO_FIX_LABEL, DOISTBOT_SPECULATIVE_FIX_LABEL } from 'doistbot-shared-contracts';
 import { logger } from '../../core/logging.js';
 import { fillPromptTemplate, loadPromptTemplateFile, resolvePromptFile, } from '../../core/prompt-template.js';
+import { withRetry } from '../../core/retry.js';
+import { requestAssigneeReview } from './assignee-review.js';
+import { GITHUB_REQUEST_TIMEOUT_MS } from './github-request.js';
+import { markPullRequestReady } from './pr-readiness.js';
 const PR_TEMPLATE_PATHS = [
     '.github/pull_request_template.md',
     '.github/PULL_REQUEST_TEMPLATE.md',
@@ -241,7 +245,7 @@ export async function commitAndPushFix(input) {
 /**
  * Commits + pushes a second fix attempt on the EXISTING iter-0 branch. Unlike
  * commitAndPushFix, this does not create a new branch — callers (the fix loop's
- * iter-1 path) need the existing draft PR to pick up the new commit, which only
+ * iter-1 path) need the existing PR to pick up the new commit, which only
  * works if we push to the same branch the PR was opened from.
  *
  * Assumes the working tree already has the iter-1 changes staged (typically by
@@ -272,6 +276,7 @@ export async function commitAndPushIteration(input) {
     });
     return { headSha };
 }
+/** Opens a draft, then marks it ready if an eligible assignee review was requested. */
 export async function openDraftFixPR(input) {
     const prBody = input.prBody
         ? stripEmptySections(input.prBody)
@@ -298,6 +303,13 @@ export async function openDraftFixPR(input) {
         base: repo.default_branch,
         draft: true,
     });
+    const requestedAssignees = await requestAssigneeReview({
+        owner: input.repoOwner,
+        repo: input.repoName,
+        prNumber: pr.number,
+        octokit: input.octokit,
+        assigneeReview: input.assigneeReview,
+    });
     try {
         const prLabel = input.fixAssessment?.classification === 'speculative'
             ? DOISTBOT_SPECULATIVE_FIX_LABEL
@@ -307,6 +319,7 @@ export async function openDraftFixPR(input) {
             repo: input.repoName,
             issue_number: pr.number,
             labels: [prLabel],
+            request: { signal: AbortSignal.timeout(GITHUB_REQUEST_TIMEOUT_MS) },
         });
     }
     catch (error) {
@@ -317,6 +330,50 @@ export async function openDraftFixPR(input) {
             error: error instanceof Error ? error.message : String(error),
         });
     }
+    if (requestedAssignees.length > 0) {
+        // Apply the autofix label before emitting ready_for_review. An accepted
+        // assignee request is sufficient, even if writing its receipt failed.
+        try {
+            await markPullRequestReady({
+                octokit: input.octokit,
+                owner: input.repoOwner,
+                repo: input.repoName,
+                prNumber: pr.number,
+            });
+            logger.info('Assignee-reviewed fix PR marked ready', {
+                task: 'issue-triage',
+                repository: `${input.repoOwner}/${input.repoName}`,
+                prNumber: pr.number,
+            });
+        }
+        catch (error) {
+            // The PR and review request already exist. Preserve both and keep
+            // the fix loop running rather than reporting PR creation failure.
+            logger.warn('Failed to mark assignee-reviewed fix PR ready', {
+                task: 'issue-triage',
+                repository: `${input.repoOwner}/${input.repoName}`,
+                prNumber: pr.number,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            try {
+                await withRetry(() => input.octokit.rest.issues.createComment({
+                    owner: input.repoOwner,
+                    repo: input.repoName,
+                    issue_number: pr.number,
+                    body: "Review was requested from the issue assignees, but I couldn't confirm that this PR was marked ready for review. Please check its status and mark it ready manually if needed.",
+                    request: { signal: AbortSignal.timeout(GITHUB_REQUEST_TIMEOUT_MS) },
+                }));
+            }
+            catch (commentError) {
+                logger.warn('Failed to report fix PR readiness failure', {
+                    task: 'issue-triage',
+                    repository: `${input.repoOwner}/${input.repoName}`,
+                    prNumber: pr.number,
+                    error: commentError instanceof Error ? commentError.message : String(commentError),
+                });
+            }
+        }
+    }
     logger.info('Fix PR created', {
         task: 'issue-triage',
         repository: `${input.repoOwner}/${input.repoName}`,
@@ -327,5 +384,6 @@ export async function openDraftFixPR(input) {
     return {
         prUrl: pr.html_url,
         prNumber: pr.number,
+        ...(requestedAssignees.length > 0 && { requestedAssignees }),
     };
 }

package/sandbox/dist/tasks/issue-triage/pr-readiness.js

@@ -0,0 +1,25 @@
+import { withRetry } from '../../core/retry.js';
+import { GITHUB_REQUEST_TIMEOUT_MS } from './github-request.js';
+/** Safe both at creation and when the later CI-driven promotion runs. */
+export async function markPullRequestReady({ octokit, owner, repo, prNumber, }) {
+    // Re-read on every attempt: a mutation may have succeeded even if its
+    // response was lost. Repeating that mutation on a ready PR would fail.
+    await withRetry(async () => {
+        const { data: pr } = await octokit.rest.pulls.get({
+            owner,
+            repo,
+            pull_number: prNumber,
+            request: { signal: AbortSignal.timeout(GITHUB_REQUEST_TIMEOUT_MS) },
+        });
+        if (!pr.draft)
+            return;
+        await octokit.graphql(`mutation($pullRequestId: ID!) {
+                markPullRequestReadyForReview(input: { pullRequestId: $pullRequestId }) {
+                    pullRequest { isDraft }
+                }
+            }`, {
+            pullRequestId: pr.node_id,
+            request: { signal: AbortSignal.timeout(GITHUB_REQUEST_TIMEOUT_MS) },
+        });
+    });
+}

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

@@ -12,10 +12,13 @@ export async function resolveTriageScope(params) {
             parsed_products: result.parsedLabels.productLabels,
             parsed_apps: result.parsedLabels.appLabels,
             parsed_teams: result.parsedLabels.teamLabels,
+            parsed_integrations: result.parsedLabels.integrationLabels,
             matched_routes: result.matchedRoutes,
+            matched_integrations: result.matchedIntegrations,
             unknown_product_labels: result.parsedLabels.unknownProductLabels,
             unknown_app_labels: result.parsedLabels.unknownAppLabels,
             unknown_team_labels: result.parsedLabels.unknownTeamLabels,
+            unknown_integration_labels: result.parsedLabels.unknownIntegrationLabels,
         });
         span.setAttributes({
             'resolution.status': result.status,

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

@@ -254,7 +254,7 @@ async function runIssueTriagePipeline(ctx, mode) {
                 extraEnv: {
                     GH_TOKEN: issueInstallationAuth.token,
                 },
-                thinkingLevel: 'high',
+                thinkingLevel: 'xhigh',
             });
             if (!triageResult.ok) {
                 await postFinalTriageComment(buildTriageFailureMessage(triageResult.error));
@@ -318,6 +318,10 @@ async function runIssueTriagePipeline(ctx, mode) {
                     issueUrl: issue.html_url ?? getIssueUrl(ctx.owner, ctx.repo, ctx.issueNumber),
                     ghToken: issueInstallationAuth.token,
                     loadRepoConfig: getCachedRepoConfig,
+                    assigneeReview: {
+                        assignees: (issue.assignees ?? []).map((assignee) => assignee.login),
+                        membershipOctokit: readOctokit,
+                    },
                 });
                 logger.info('triage.fix_attempted', {
                     task: 'issue-triage',

package/sandbox/dist/tasks/review/thinking-level.js

@@ -3,7 +3,7 @@ export function getReviewThinkingLevel(model) {
         case 'deepseek':
             return 'high';
         case 'openai':
-            return 'high';
+            return 'xhigh';
         case 'grok':
             return 'high';
         case 'zai':

package/sandbox/src/review/prompts/ai-internal-tools.md

@@ -202,7 +202,7 @@ flowchart TD
     Agent --> NonSensitive
 ```
 
-> Note: see [`examples/internal-ai-service/`](https://github.com/Doist/platform-standards/tree/main/examples/internal-ai-service/) for the server-side service and [`examples/local-cli/`](https://github.com/Doist/platform-standards/tree/main/examples/local-cli/) for the thin local CLI. The example implements Zendesk only; the same pattern applies to Sentry/Datadog.
+> Note: see [`examples/internal-ai-service/`](https://github.com/Doist/standards/tree/main/examples/internal-ai-service/) for the server-side service and [`examples/local-cli/`](https://github.com/Doist/standards/tree/main/examples/local-cli/) for the thin local CLI. The example implements Zendesk only; the same pattern applies to Sentry/Datadog.
 
 ### How to read this diagram
 
@@ -236,9 +236,9 @@ Think of the diagram as three separate rooms, each with different access rules:
 
 1. **Remove** the direct connections to Zendesk, Sentry, and Datadog from your local AI setup.
 
-2. **Set up an internal service** (the Platform team can help) that fetches and cleans data before passing it to the AI — see [`examples/internal-ai-service/main.go`](https://github.com/Doist/platform-standards/tree/main/examples/internal-ai-service/main.go) for a working reference. It should only return what's needed to answer the question — never raw personal information.
+2. **Set up an internal service** (the Platform team can help) that fetches and cleans data before passing it to the AI — see [`examples/internal-ai-service/main.go`](https://github.com/Doist/standards/tree/main/examples/internal-ai-service/main.go) for a working reference. It should only return what's needed to answer the question — never raw personal information.
 
-3. **Point your local tool at that internal service** instead of at the third-party tools directly — see [`examples/local-cli/main.go`](https://github.com/Doist/platform-standards/tree/main/examples/local-cli/main.go) for a working reference.
+3. **Point your local tool at that internal service** instead of at the third-party tools directly — see [`examples/local-cli/main.go`](https://github.com/Doist/standards/tree/main/examples/local-cli/main.go) for a working reference.
 
 4. **Keep your Github, Twist, and Outline connections as-is** — those don't hold user personal data, so they're fine to use directly.
 

package/sandbox/src/review/prompts/backend-repository-standards.md

@@ -0,0 +1,102 @@
+# Standard: Backend Repositories
+
+| 📄 Document Type | Team Standard (Backend)                                                                                                   |
+| :--------------- | :------------------------------------------------------------------------------------------------------------------------ |
+| 🎯 Status        | Draft                                                                                                                     |
+| 👤 Owner         | Felipe Rodrigues                                                                                                          |
+| 📅 Last Reviewed | 2026-09-08                                                                                                                |
+| 🗂️ References    | [Standard: Service Production Readiness](https://handbook.doist.com/doc/standard-service-production-readiness-qgNRng8TJx) |
+| 📌 Version       | 0.2                                                                                                                       |
+
+This standard applies to **all backend repositories at Doist, regardless of language or current ownership.** Today that means `Todoist` and other repositories already owned by the Backend team as well as newer backend services such as `todoist-id` and `automations` - currently developed by squads, and expected to come under Backend team ownership over time.
+
+Meeting this standard is part of what makes that handover possible.
+
+## Tests
+
+Every repository must have automated tests. A repository with no tests is not production-ready.
+
+- Tests must run in CI on every pull request.
+- Tests must run in CI on every merge to `main`.
+- Deployments must be gated on tests passing. In GitHub Actions, the deploy job must depend on the test job — via `needs: test` in the same workflow, or by invoking the test workflow as a reusable workflow and depending on that job. A deploy that races its own test run is not gated.
+
+## Branch Protection
+
+Tests that exist but are never enforced provide false confidence. The `main` branch must be protected:
+
+- Changes land via pull request — no direct pushes to `main`.
+- Test, lint, and type-check jobs are configured as **required status checks**, so a PR cannot merge while they fail or haven't run.
+
+## Code Quality Hooks
+
+- Pre-commit hooks must be used to enforce formatting, linting, and repo hygiene. The runner is language-specific: [prek](https://prek.j178.dev) in Python repositories, [husky](https://typicode.github.io/husky/) in JavaScript/TypeScript ones.
+- The same checks must also run in CI on every pull request and merge to `main` (e.g. `prek run --all-files`, or the `npm` scripts the hooks call). Hooks that only run locally are advisory; developers can skip or misconfigure them.
+
+## README
+
+Every repository must have a `README.md` with at least:
+
+- Project description
+- How to run the project locally
+- How to run tests
+- How to deploy the project
+
+## Dependency Updates
+
+Automated dependency updates (Renovate or Dependabot) must be enabled. Update PRs go through the same CI gates as any other change.
+
+## Python Requirements
+
+Python repositories must use the following stack (mirroring the main Todoist codebase):
+
+| Concern                         | Tool                         |
+| ------------------------------- | ---------------------------- |
+| Project & dependency management | `uv`                         |
+| Minimum Python version          | 3.13                         |
+| Tests                           | `pytest`                     |
+| Linting & formatting            | `ruff check` + `ruff format` |
+| Git hooks                       | `prek`                       |
+| Type checking                   | `mypy` and `pyrefly`         |
+| Dead code detection             | `vulture`                    |
+
+- Dependencies in `pyproject.toml` must be pinned with upper bounds (`>=X.Y,<X+1`).
+- Type hints are mandatory on production code.
+
+## JavaScript / TypeScript Requirements
+
+JavaScript and TypeScript repositories must use the following stack (mirroring `automations`, our newest backend TS project):
+
+| Concern                         | Tool                                            |
+| ------------------------------- | ----------------------------------------------- |
+| Language                        | TypeScript                                      |
+| Runtime                         | Node.js — current LTS major                     |
+| Project & dependency management | `npm` (workspaces for monorepos)                |
+| Tests                           | `vitest`                                        |
+| Linting & formatting            | `oxlint` + `oxfmt`                              |
+| Git hooks                       | `husky`                                         |
+| Type checking                   | `tsc --noEmit`, exposed as `npm run type-check` |
+
+- Production code must be TypeScript. Plain JavaScript only where a tool requires it.
+- The Node version must be pinned in `engines` and in a version file (`.node-version`, which `actions/setup-node` reads via `node-version-file`; `.nvmrc` alongside it if people use `nvm`). Version files pin Node only, so pin the npm major in `engines` as well.
+- `engine-strict=true` must be set in `.npmrc`. Without it npm only warns on an `engines` mismatch, and the pins above do not actually stop local, CI and container builds from drifting apart.
+- Dependencies in `package.json` must be pinned to exact versions, with the lockfile committed.
+- The TypeScript config must extend the shared `@doist/tsconfig` base and keep `strict` on.
+
+## Related Documents
+
+This standard complements the Doist-wide [Service Production Readiness](https://handbook.doist.com/doc/standard-service-production-readiness-qgNRng8TJx) standard: that one covers how a service must _behave_ in production while this one covers the baseline health a _repository_ must have before its code reaches production.
+
+Related engineering-wide guidelines:
+
+- [GitHub Repository Guidelines](https://handbook.doist.com/doc/github-repository-guidelines-iJNZ0D2vLN)
+- [Automate linting and formatting](https://handbook.doist.com/doc/automate-linting-and-formatting-omSECLKiJI)
+- [Keeping dependencies up-to-date](https://handbook.doist.com/doc/keeping-dependencies-up-to-date-Qf28E929N5)
+
+---
+
+## Open questions/Possible future expansions to the Standard
+
+- Type checkers: Todoist currently runs `mypy`, `ty`, and `pyrefly` in parallel, but that is an evaluation state, not a recommendation (see [Choosing type checkers for Todoist](https://comms.todoist.com/69/ch/BH4VumxwScG1NAiomtcBq/t/CbVia3jW38koSRmHWXSeV/)). A June 2026 attempt to remove mypy was reverted after it left real gaps (pyrefly's legacy config disabled core checks; ty lacks Pydantic support). Current direction: pyrefly in strict mode is the candidate primary, mypy stays as the mature baseline, ty is a secondary bet pending Pydantic support. `mypy` + `pyrefly` therefore remains the right baseline for new repos; revisit when ty matures.
+- Maybe create a [Copier](https://copier.readthedocs.io/en/stable/) template for Python repos — and an equivalent for TS ones — so new services start compliant? Or even a small template repo with “sane defaults” for our tooling.
+- Dead code detection has no JS/TS entry yet. Python repos run `vulture`; `knip` is the closest equivalent, but nothing runs it today.
+- Define the baseline ruff rule set / prek hook list based on the Todoist codebase (its `prek.toml` is a good starting point: ruff, standard pre-commit-hooks, shellcheck, hadolint, mypy/type checkers, vulture on pre-push).

package/sandbox/src/review/prompts/outline-map.json

@@ -1,22 +1,26 @@
 {
     "workload-placement.md": {
-        "id": "26dac3b3-fc42-4e03-a559-ccff6b980557",
-        "url": "https://handbook.doist.com/doc/standard-workload-placement-j2Xe36eQar"
+        "id": "",
+        "url": "https://handbook.doist.com/doc/standard-workload-placement-"
     },
     "secrets-management.md": {
-        "id": "c0daf063-8120-4ace-a26c-fd6f64656324",
-        "url": "https://handbook.doist.com/doc/standard-secrets-management-wbKmIfrtgr"
+        "id": "",
+        "url": "https://handbook.doist.com/doc/standard-secrets-management-"
     },
     "ai-internal-tools.md": {
-        "id": "02f9d168-f91a-4632-88d9-4d25f4b33063",
-        "url": "https://handbook.doist.com/doc/standard-internal-ai-tools-zU0fqnhpmC"
+        "id": "",
+        "url": "https://handbook.doist.com/doc/standard-internal-ai-tools-"
     },
     "service-production-readiness.md": {
-        "id": "1f4fba5d-9ca6-43bb-97b5-cc0ee8aad3cc",
-        "url": "https://handbook.doist.com/doc/standard-service-production-readiness-qgNRng8TJx"
+        "id": "",
+        "url": "https://handbook.doist.com/doc/standard-service-production-readiness-"
     },
     "observability-standard.md": {
-        "id": "e9fe25ca-453d-40b2-b4b0-ef4cdcb5f030",
-        "url": "https://handbook.doist.com/doc/standard-observability-vWRaOfitho"
+        "id": "",
+        "url": "https://handbook.doist.com/doc/standard-observability-"
+    },
+    "backend-repository-standards.md": {
+        "id": "",
+        "url": "https://handbook.doist.com/doc/standard-backend-repositories-"
     }
 }

package/sandbox/src/review/prompts/service-production-readiness.md

@@ -49,7 +49,7 @@ All services must produce structured, meaningful logs.
 
 Logs should support operational debugging and monitoring.
 
-See the Observability standard for more details. TODO(artyom): add a link once it's finalized.
+See [the Observability standard for more details](https://handbook.doist.com/doc/standard-observability-vWRaOfitho).
 
 ## Configuration Management
 
@@ -59,7 +59,7 @@ Configuration must be provided via environment variables.
 - Env files are allowed only if variables can be overridden by the environment.
 - Secrets must come from environment variables or read directly from a secrets management service (AWS Secrets Manager).
 
-See the Secrets Management standard for more details. TODO(artyom): add a link once it's finalized.
+See [the Secrets Management standard for more details](https://handbook.doist.com/doc/standard-secrets-management-wbKmIfrtgr).
 
 ## State Persistence