@orboto/mcp 0.203.0 → 0.204.0

package/dist/tools/list-projects.js

@@ -4,13 +4,13 @@
 import { z } from 'zod';
 export const listProjectsToolConfig = {
     title: 'List projects',
-    description: 'Return projects the authenticated user can see (key, name, status). Useful first step of a workflow. '
-        + 'If you are after one project, pass `query` to filter by key/name instead of pulling the whole list - '
-        + 'and note you can usually use a project key directly with other tools without listing at all. '
-        + 'When the result says it is partial, refine with `query` rather than re-calling.',
+    description: 'Projects the user can see. To find one, pass `search` (key, name, description, customer) '
+        + 'instead of pulling the whole list; a project key usually works directly with other tools. '
+        + 'When the result is partial, refine rather than re-call.',
     inputSchema: z.object({
-        query: z.string().optional().describe('Substring matched against key or name.'),
-        limit: z.number().int().min(1).max(200).optional().describe('Max projects. Default 50.'),
+        search: z.string().optional().describe('Key, name, description, customer.'),
+        query: z.string().optional().describe('Key/name substring.'),
+        limit: z.number().int().min(1).max(200).optional().describe('Default 50.'),
     }).shape,
     outputSchema: z.object({
         projects: z.array(z.object({
@@ -27,22 +27,28 @@ export const listProjectsToolConfig = {
     annotations: { readOnlyHint: true, idempotentHint: true },
 };
 export function makeListProjectsHandler(client) {
-    return async ({ query, limit } = {}) => {
-        const projects = await client.get('/projects');
+    return async ({ search, query, limit } = {}) => {
+        const s = (search ?? '').trim();
+        const [projects, found] = await Promise.all([
+            client.get('/projects'),
+            s ? client.get(`/projects?search=${encodeURIComponent(s)}`) : Promise.resolve(null),
+        ]);
         const q = (query ?? '').trim().toLowerCase();
+        const base = found ?? projects;
         const matched = q
-            ? projects.filter((p) => `${p.key} ${p.name}`.toLowerCase().includes(q))
-            : projects;
+            ? base.filter((p) => `${p.key} ${p.name}`.toLowerCase().includes(q))
+            : base;
+        const term = [s, q].filter(Boolean).map((v) => `"${v}"`).join(' and ');
         const cap = Math.min(limit ?? 50, 200);
         const shown = matched.slice(0, cap);
         const rows = shown.map((p) => ({ id: p.id, key: p.key, name: p.name, status: p.status, description: p.description }));
         const lines = rows.map((r) => `- ${r.key} - ${r.name} (${r.status})`);
         const partial = shown.length < matched.length;
         const footer = matched.length === 0
-            ? (q ? `No projects match "${q}".` : 'No projects visible to this user.')
+            ? (term ? `No projects match ${term}.` : 'No projects visible to this user.')
             : partial
-                ? `\nShowing first ${shown.length} of ${matched.length} match(es) (of ${projects.length} total) - pass a narrower query to filter.`
-                : `\n(${matched.length} project(s)${q ? ` matching "${q}"` : ''}, complete.)`;
+                ? `\nShowing first ${shown.length} of ${matched.length} match(es) (of ${projects.length} total) - pass a narrower search to filter.`
+                : `\n(${matched.length} project(s)${term ? ` matching ${term}` : ''}, complete.)`;
         const text = matched.length === 0 ? footer : lines.join('\n') + footer;
         return {
             content: [{ type: 'text', text }],

package/dist/tools/list-projects.test.js

@@ -57,6 +57,27 @@ describe('tools/list-projects', () => {
         expect(text).toContain('Showing first 2 of 5 match(es)');
         expect(result.structuredContent).toMatchObject({ total: 5, totalProjects: 5 });
     });
+    it('ORB-2203: search asks the API with ?search= and still counts every visible project', async () => {
+        const all = [
+            { id: 'p1', key: 'ACME', name: 'Acme', description: 'Customer portal', status: 'active' },
+            { id: 'p2', key: 'TOOL', name: 'Internal Tools', description: null, status: 'draft' },
+        ];
+        const fetchSpy = vi.spyOn(globalThis, 'fetch').mockImplementation(async (input) => {
+            const url = String(input);
+            const body = url.includes('search=') ? [all[0]] : all;
+            return { ok: true, status: 200, statusText: 'OK', json: async () => body };
+        });
+        const result = await makeListProjectsHandler(client)({ search: ' portal ' });
+        const urls = fetchSpy.mock.calls.map(([input]) => String(input));
+        expect(urls.some((u) => u.endsWith('/projects?search=portal'))).toBe(true);
+        expect(result.content[0]).toEqual({ type: 'text', text: '- ACME - Acme (active)\n(1 project(s) matching "portal", complete.)' });
+        expect(result.structuredContent).toMatchObject({ total: 1, totalProjects: 2, query: null });
+    });
+    it('ORB-2203: without search only the plain list is fetched', async () => {
+        const fetchSpy = mockFetch([]);
+        await makeListProjectsHandler(client)({ query: 'x' });
+        expect(fetchSpy.mock.calls.map(([input]) => String(input)).every((u) => !u.includes('search='))).toBe(true);
+    });
     it('renders an empty-state text block when the API returns no rows', async () => {
         mockFetch([]);
         const result = await makeListProjectsHandler(client)();

package/dist/tools/phase-b-tools.test.js

@@ -490,6 +490,27 @@ describe('orboto_search', () => {
         expect(sc.total).toBe(42);
         expect(sc.hasMore).toBe(true);
     });
+    it('ORB-2201: passes the jump types and renders project and milestone hits by key', async () => {
+        const calls = stub([
+            {
+                json: {
+                    items: [
+                        { type: 'project', id: 'p1', key: 'ACME', projectKey: 'ACME', title: 'Acme', excerpt: '', projectId: 'p1', projectName: 'Acme', spaceId: null, spaceName: null, url: '/projects/acme', rank: 2000 },
+                        { type: 'milestone', id: 'm1', key: 'ACME-M1', projectKey: 'ACME', title: 'Launch', excerpt: '', projectId: 'p1', projectName: 'Acme', spaceId: null, spaceName: null, url: '/projects/acme?milestoneIds=m1', rank: 200 },
+                    ],
+                    nextCursor: null,
+                    total: 2,
+                },
+            },
+        ]);
+        const res = await makeSearchHandler(client)({ query: 'acme', types: ['project', 'milestone'] });
+        expect(calls[0]).toContain('types=project%2Cmilestone');
+        const text = res.content[0].text;
+        expect(text).toContain('- [PROJECT ACME] Acme');
+        expect(text).toContain('- [MILESTONE ACME-M1 · Acme] Launch');
+        const sc = res.structuredContent;
+        expect(sc.hits.map((h) => [h.key, h.projectKey])).toEqual([['ACME', 'ACME'], ['ACME-M1', 'ACME']]);
+    });
 });
 describe('doc tools', () => {
     it('list: uses DocSpace.type to label scope, not a joined projectName', async () => {

package/dist/tools/search.js

@@ -5,13 +5,13 @@
  */
 import { z } from 'zod';
 import { resolveProjectByKey } from './shared.js';
+const SEARCH_TYPES = ['ticket', 'comment', 'doc', 'project', 'milestone', 'space', 'customer'];
 export const searchToolConfig = {
     title: 'Search across orboto',
-    description: 'Full-text search across tickets, comments, and docs. Honours the caller\'s visibility - private tickets and internal comments never appear unless the caller can already see them. Recall (ORB-1695): when the strict all-terms pass finds nothing, the server automatically retries with an OR-relaxed pass plus semantic (embedding) recall - the response\'s `pass` field says which pass produced the hits, and relaxed-pass hits deserve a skeptical read (they matched SOME terms or only the meaning, not all terms). Still prefer a single distinctive STABLE token (file/component/error-string fragment like "AdminCodesPage") and search the SYMPTOM, not your intended fix.',
+    description: 'Search tickets, comments and docs; `types` adds projects, milestones, spaces, customers. Content matches full text, jump types match key and name; `types` defaults to ticket, comment, doc. Honours the caller\'s visibility - private tickets and internal comments never appear unless the caller can already see them. Recall (ORB-1695): when the strict all-terms pass finds nothing, the server automatically retries with an OR-relaxed pass plus semantic (embedding) recall - the response\'s `pass` field says which pass produced the hits, and relaxed-pass hits deserve a skeptical read (they matched SOME terms or only the meaning, not all terms). Still prefer a single distinctive STABLE token (file/component/error-string fragment like "AdminCodesPage") and search the SYMPTOM, not your intended fix.',
     inputSchema: z.object({
         query: z.string().min(1).describe('Search terms, e.g. "queue worker retry".'),
-        types: z.array(z.enum(['ticket', 'comment', 'doc'])).optional()
-            .describe('Restrict to entity types. Omit for all.'),
+        types: z.array(z.enum(SEARCH_TYPES)).optional(),
         projectKey: z.string().optional().describe('Restrict to one project.'),
         limit: z.number().int().min(1).max(50).default(15),
     }).shape,
@@ -39,9 +39,10 @@ export function makeSearchHandler(client) {
             ? `No hits for "${input.query}".`
             : `Hits${headerHint}${relaxedNote}:\n\n` + res.items.map((h) => {
                 const tag = h.type.toUpperCase();
-                const ident = h.ticketKey ?? h.id;
-                const project = h.projectName ? ` · ${h.projectName}` : '';
-                return `- [${tag} ${ident}${project}] ${h.title}\n  ${h.excerpt}`;
+                const ident = h.ticketKey ?? h.key ?? h.id;
+                const project = h.projectName && h.type !== 'project' ? ` · ${h.projectName}` : '';
+                const excerpt = h.excerpt ? `\n  ${h.excerpt}` : '';
+                return `- [${tag} ${ident}${project}] ${h.title}${excerpt}`;
             }).join('\n\n');
         return {
             content: [{ type: 'text', text }],
@@ -56,6 +57,8 @@ export function makeSearchHandler(client) {
                     title: h.title,
                     excerpt: h.excerpt,
                     ticketKey: h.ticketKey ?? null,
+                    key: h.key ?? h.ticketKey ?? null,
+                    projectKey: h.projectKey ?? null,
                     projectName: h.projectName,
                     spaceName: h.spaceName,
                     url: h.url,

package/dist/tools/ticket-writes.js

@@ -186,7 +186,7 @@ function preflightResult(preflight, projectKey) {
         preflight.ok
             ? `✓ Pre-flight clean for ${projectKey} - re-send the same arguments without dryRun to create the ticket.`
             : `⛔ Pre-flight BLOCKED for ${projectKey} (${preflight.blockedBy.join(', ')}) - nothing was created. Fix the payload and run the pre-flight again.`,
-        `  ${icon[preflight.verdicts.language.severity]} language: ${preflight.verdicts.language.message}`,
+        `  ${icon[preflight.verdicts.language.severity]} language: ${preflight.verdicts.language.message}${preflight.verdicts.language.hint ? ` Keep it only on purpose: ${preflight.verdicts.language.hint.query}.` : ''}`,
         `  ${icon[preflight.verdicts.type.severity]} type: ${preflight.verdicts.type.message}`,
         `  ${icon[preflight.verdicts.labels.severity]} labels: ${preflight.verdicts.labels.message}`,
         `  ${icon[preflight.verdicts.duplicates.severity]} duplicates: ${preflight.verdicts.duplicates.message}`,
@@ -257,12 +257,13 @@ function languageBlockResult(err, verb) {
     if (!parsed.languageWarning)
         return null;
     const lw = parsed.languageWarning;
+    const retry = `retry the same call with ${parsed.hint?.query ?? 'allowLanguageMismatch=true'}`;
     const text = `⛔ ${verb} blocked - strict ticket-language enforcement is on.\n` +
         `This content reads as "${lw.detected}" but the workspace language is "${lw.expected}".\n` +
-        `Rewrite it in ${lw.expected.toUpperCase()}, or - only if you are sure the language is intentional - retry the same call with allowLanguageMismatch=true.`;
+        `Rewrite it in ${lw.expected.toUpperCase()}, or - only if you are sure the language is intentional - ${retry}.`;
     return {
         content: [{ type: 'text', text }],
-        structuredContent: { blocked: true, languageWarning: lw },
+        structuredContent: { blocked: true, languageWarning: lw, ...(parsed.hint ? { hint: parsed.hint } : {}) },
         isError: true,
     };
 }

package/dist/tools/ticket-writes.test.js

@@ -228,6 +228,25 @@ describe('orboto_create_ticket', () => {
         expect(sc.blocked).toBe(true);
         expect(sc.languageWarning.severity).toBe('block');
     });
+    it('reads the way out from the hint, never from the sentence written for a person (ORB-2200)', async () => {
+        const blockBody = JSON.stringify({
+            error: 'This ticket looks like it is written in a different language (de) than this project expects (en). If the language is intentional, you can keep the ticket as it is.',
+            errorKey: 'errors.tickets.language_mismatch',
+            languageWarning: { code: 'language_mismatch', severity: 'block', detected: 'de', expected: 'en' },
+            hint: { query: 'allowLanguageMismatch=true' },
+        });
+        vi.spyOn(globalThis, 'fetch').mockImplementation(async (_url, init) => {
+            if ((init?.method ?? 'GET') === 'GET') {
+                return { ok: true, status: 200, statusText: 'OK', json: async () => PROJ, text: async () => '' };
+            }
+            return { ok: false, status: 422, statusText: 'Unprocessable', json: async () => ({}), text: async () => blockBody };
+        });
+        const res = await makeCreateTicketHandler(client)({ projectKey: 'ACME', title: 'Authentifizierung schlägt fehl bei externen Nutzern' });
+        const text = res.content[0].text;
+        expect(text).toContain('retry the same call with allowLanguageMismatch=true');
+        expect(text).not.toContain('keep the ticket as it is');
+        expect(res.structuredContent.hint).toEqual({ query: 'allowLanguageMismatch=true' });
+    });
     it('passes allowLanguageMismatch as a query param when the override is set (ORB-990)', async () => {
         let createUrl = '';
         vi.spyOn(globalThis, 'fetch').mockImplementation(async (url, init) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orboto/mcp",
-  "version": "0.203.0",
+  "version": "0.204.0",
   "description": "Model Context Protocol server for orboto - exposes tickets, projects, milestones, time, docs, primer-facts, alerts and absences as MCP tools for Claude Desktop / Cursor / Copilot Chat / any MCP-aware AI client.",
   "license": "MIT",
   "type": "module",