huly-mcp-selfhost 2.1.0 → 3.2.0

package/dist/tools/testing.d.ts

@@ -0,0 +1,234 @@
+export declare const TM: {
+    readonly Project: 'testManagement:class:TestProject';
+    readonly Suite: 'testManagement:class:TestSuite';
+    readonly Case: 'testManagement:class:TestCase';
+    readonly Plan: 'testManagement:class:TestPlan';
+    readonly PlanItem: 'testManagement:class:TestPlanItem';
+    readonly Run: 'testManagement:class:TestRun';
+    readonly Result: 'testManagement:class:TestResult';
+    readonly NoParent: 'testManagement:ids:NoParent';
+    readonly SpaceType: 'testManagement:spaceType:DefaultProject';
+    readonly TypeMixin: 'testManagement:mixin:DefaultProjectTypeData';
+};
+export declare const CASE_TYPES: readonly ['Functional', 'Performance', 'Regression', 'Security', 'Smoke', 'Usability'];
+export declare const CASE_PRIORITIES: readonly ['Low', 'Medium', 'High', 'Urgent'];
+export declare const CASE_STATUSES: readonly ['Draft', 'ReadyForReview', 'FixReviewComments', 'Approved', 'Rejected'];
+export declare const RESULT_STATUSES: readonly ['Untested', 'Blocked', 'Passed', 'Failed'];
+export declare const idx: (list: readonly string[], v: string) => number;
+export declare const name: (list: readonly string[], i: number | undefined) => string;
+export declare function findProject(client: any, ref: string): Promise<any>;
+export declare function findSuite(client: any, project: any, ref: string): Promise<any>;
+export declare function findDoc(client: any, _class: string, id: string, what: string): Promise<any>;
+export declare const listTestProjects: (args: {
+    workspace?: string | undefined;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const createTestProject: (args: {
+    workspace: string;
+    name: string;
+    description?: string | undefined;
+    isPrivate: boolean;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const listTestCases: (args: {
+    workspace?: string | undefined;
+    project: string;
+    suite?: string | undefined;
+    status?: "Approved" | "Draft" | "FixReviewComments" | "ReadyForReview" | "Rejected" | undefined;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const createTestSuite: (args: {
+    workspace: string;
+    project: string;
+    name: string;
+    description?: string | undefined;
+    parent?: string | undefined;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const getTestCase: (args: {
+    workspace?: string | undefined;
+    caseId: string;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const createTestCase: (args: {
+    workspace: string;
+    project: string;
+    suite: string;
+    name: string;
+    description?: string | undefined;
+    type: "Functional" | "Performance" | "Regression" | "Security" | "Smoke" | "Usability";
+    priority: "High" | "Low" | "Medium" | "Urgent";
+    status: "Approved" | "Draft" | "FixReviewComments" | "ReadyForReview" | "Rejected";
+    assignee?: string | undefined;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const updateTestCase: (args: {
+    workspace: string;
+    caseId: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    type?: "Functional" | "Performance" | "Regression" | "Security" | "Smoke" | "Usability" | undefined;
+    priority?: "High" | "Low" | "Medium" | "Urgent" | undefined;
+    status?: "Approved" | "Draft" | "FixReviewComments" | "ReadyForReview" | "Rejected" | undefined;
+    assignee?: string | null | undefined;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const deleteTestCase: (args: {
+    workspace: string;
+    caseId: string;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const listTestPlans: (args: {
+    workspace?: string | undefined;
+    project: string;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const createTestPlan: (args: {
+    workspace: string;
+    project: string;
+    name: string;
+    suites?: string[] | undefined;
+    caseIds?: string[] | undefined;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const createTestRun: (args: {
+    workspace: string;
+    project: string;
+    name: string;
+    plan?: string | undefined;
+    suites?: string[] | undefined;
+    caseIds?: string[] | undefined;
+    dueDate?: string | undefined;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const listTestRuns: (args: {
+    workspace?: string | undefined;
+    project: string;
+    limit: number;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const getTestRun: (args: {
+    workspace?: string | undefined;
+    runId: string;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const setTestResult: (args: {
+    workspace: string;
+    result: string;
+    runId?: string | undefined;
+    status: "Blocked" | "Failed" | "Passed" | "Untested";
+    comment?: string | undefined;
+    assignee?: string | null | undefined;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const updateTestSuite: (args: {
+    workspace: string;
+    project: string;
+    suite: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    parent?: string | null | undefined;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const deleteTestSuite: (args: {
+    workspace: string;
+    project: string;
+    suite: string;
+    recursive?: boolean | undefined;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const updateTestRun: (args: {
+    workspace: string;
+    runId: string;
+    name?: string | undefined;
+    dueDate?: string | null | undefined;
+    description?: string | undefined;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const deleteTestRun: (args: {
+    workspace: string;
+    runId: string;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const deleteTestPlan: (args: {
+    workspace: string;
+    project: string;
+    plan: string;
+}) => Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;

package/dist/tools/testing.js

@@ -0,0 +1,401 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteTestPlan = exports.deleteTestRun = exports.updateTestRun = exports.deleteTestSuite = exports.updateTestSuite = exports.setTestResult = exports.getTestRun = exports.listTestRuns = exports.createTestRun = exports.createTestPlan = exports.listTestPlans = exports.deleteTestCase = exports.updateTestCase = exports.createTestCase = exports.getTestCase = exports.createTestSuite = exports.listTestCases = exports.createTestProject = exports.listTestProjects = exports.name = exports.idx = exports.RESULT_STATUSES = exports.CASE_STATUSES = exports.CASE_PRIORITIES = exports.CASE_TYPES = exports.TM = void 0;
+exports.findProject = findProject;
+exports.findSuite = findSuite;
+exports.findDoc = findDoc;
+// Test management: projects → suites (nested) → cases; plans pick cases; runs hold one result per case.
+// Mirrors Huly's test-management UI (CreateTestSuite, CreateTestCase, NewTestPlanPanel, NewTestRunPanel).
+const core_1 = require("@hcengineering/core");
+const connection_1 = require("../connection");
+const errors_1 = require("../utils/errors");
+const content_1 = require("../utils/content");
+const format_1 = require("../utils/format");
+const people_1 = require("../utils/people");
+exports.TM = {
+    Project: 'testManagement:class:TestProject',
+    Suite: 'testManagement:class:TestSuite',
+    Case: 'testManagement:class:TestCase',
+    Plan: 'testManagement:class:TestPlan',
+    PlanItem: 'testManagement:class:TestPlanItem',
+    Run: 'testManagement:class:TestRun',
+    Result: 'testManagement:class:TestResult',
+    NoParent: 'testManagement:ids:NoParent',
+    SpaceType: 'testManagement:spaceType:DefaultProject',
+    TypeMixin: 'testManagement:mixin:DefaultProjectTypeData'
+};
+exports.CASE_TYPES = ['Functional', 'Performance', 'Regression', 'Security', 'Smoke', 'Usability'];
+exports.CASE_PRIORITIES = ['Low', 'Medium', 'High', 'Urgent'];
+exports.CASE_STATUSES = ['Draft', 'ReadyForReview', 'FixReviewComments', 'Approved', 'Rejected'];
+exports.RESULT_STATUSES = ['Untested', 'Blocked', 'Passed', 'Failed'];
+const idx = (list, v) => list.indexOf(v);
+exports.idx = idx;
+const name = (list, i) => (i != null ? list[i] : undefined) ?? '—';
+exports.name = name;
+async function findProject(client, ref) {
+    const all = await client.findAll(exports.TM.Project, {});
+    const hits = all.filter((p) => p._id === ref || String(p.name).toLowerCase() === ref.toLowerCase());
+    if (hits.length === 1)
+        return hits[0];
+    if (hits.length > 1)
+        throw new Error(`Test project '${ref}' is ambiguous: ${hits.map((p) => p._id).join(', ')}.`);
+    throw new Error(`Test project '${ref}' not found. Available: ${all.map((p) => p.name).join(', ') || 'none'}.`);
+}
+async function findSuite(client, project, ref) {
+    const suites = await client.findAll(exports.TM.Suite, { space: project._id });
+    const hits = suites.filter((s) => s._id === ref || String(s.name).toLowerCase() === ref.toLowerCase());
+    if (hits.length === 1)
+        return hits[0];
+    if (hits.length > 1)
+        throw new Error(`Suite '${ref}' is ambiguous — use its id: ${hits.map((s) => s._id).join(', ')}.`);
+    throw new Error(`Suite '${ref}' not found in ${String(project.name)}.`);
+}
+async function findDoc(client, _class, id, what) {
+    const doc = await client.findOne(_class, { _id: id });
+    if (doc == null)
+        throw new Error(`${what} '${id}' not found.`);
+    return doc;
+}
+exports.listTestProjects = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const projects = await client.findAll(exports.TM.Project, { archived: false });
+    if (projects.length === 0)
+        return 'No test projects.';
+    const lines = [];
+    for (const p of projects) {
+        const cases = await client.findAll(exports.TM.Case, { space: p._id }, { limit: 1, total: true });
+        const runs = await client.findAll(exports.TM.Run, { space: p._id }, { limit: 1, total: true });
+        lines.push(`- **${String(p.name)}** — ${String(cases.total ?? cases.length)} case(s), ${String(runs.total ?? runs.length)} run(s) — \`${String(p._id)}\``);
+    }
+    return `## Test projects (${projects.length})\n\n${lines.join('\n')}`;
+});
+exports.createTestProject = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const existing = await client.findAll(exports.TM.Project, {});
+    const same = existing.find((p) => String(p.name).toLowerCase() === args.name.toLowerCase());
+    if (same != null)
+        return `ℹ️ Test project **${String(same.name)}** already exists — \`${String(same._id)}\`.`;
+    const me = await (0, people_1.currentAccountUuid)(client);
+    const id = await client.createDoc(exports.TM.Project, 'core:space:Space', {
+        name: args.name, description: args.description ?? '', private: args.isPrivate, members: [me], owners: [me], archived: false, type: exports.TM.SpaceType
+    });
+    await client.createMixin(id, exports.TM.Project, 'core:space:Space', exports.TM.TypeMixin, {});
+    return `✅ Test project **${args.name}** created — \`${String(id)}\`.`;
+});
+exports.listTestCases = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const project = await findProject(client, args.project);
+    const suites = await client.findAll(exports.TM.Suite, { space: project._id }, { sort: { name: core_1.SortingOrder.Ascending } });
+    const query = { space: project._id };
+    if (args.status != null)
+        query.status = (0, exports.idx)(exports.CASE_STATUSES, args.status);
+    const cases = await client.findAll(exports.TM.Case, query, { sort: { name: core_1.SortingOrder.Ascending } });
+    const people = await (0, people_1.peopleNames)(client);
+    const root = args.suite != null ? (await findSuite(client, project, args.suite))._id : exports.TM.NoParent;
+    const lines = [];
+    const walk = (parent, depth) => {
+        for (const s of suites.filter((x) => x.parent === parent)) {
+            lines.push(`${'  '.repeat(depth)}- 📂 **${String(s.name)}** — \`${String(s._id)}\``);
+            for (const c of cases.filter((x) => x.attachedTo === s._id)) {
+                const who = c.assignee != null ? ` · @${people.get(c.assignee) ?? '?'}` : '';
+                lines.push(`${'  '.repeat(depth + 1)}- ${String(c.name)} [${(0, exports.name)(exports.CASE_TYPES, c.type)}, ${(0, exports.name)(exports.CASE_PRIORITIES, c.priority)}, ${(0, exports.name)(exports.CASE_STATUSES, c.status)}]${who} — \`${String(c._id)}\``);
+            }
+            if (depth < 20)
+                walk(s._id, depth + 1);
+        }
+    };
+    if (args.suite != null) {
+        const s = suites.find((x) => x._id === root);
+        lines.push(`- 📂 **${String(s.name)}** — \`${String(s._id)}\``);
+        for (const c of cases.filter((x) => x.attachedTo === root))
+            lines.push(`  - ${String(c.name)} [${(0, exports.name)(exports.CASE_TYPES, c.type)}, ${(0, exports.name)(exports.CASE_PRIORITIES, c.priority)}, ${(0, exports.name)(exports.CASE_STATUSES, c.status)}] — \`${String(c._id)}\``);
+        walk(root, 1);
+    }
+    else
+        walk(root, 0);
+    if (lines.length === 0)
+        return `No suites in ${String(project.name)} yet — create one with create_test_suite.`;
+    return `## ${String(project.name)}: ${cases.length} case(s)\n\n${lines.join('\n')}`;
+});
+exports.createTestSuite = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const project = await findProject(client, args.project);
+    const parent = args.parent != null ? await findSuite(client, project, args.parent) : undefined;
+    const id = await client.createDoc(exports.TM.Suite, project._id, { name: args.name, description: args.description ?? '', parent: parent?._id ?? exports.TM.NoParent });
+    return `✅ Suite **${args.name}** created${parent != null ? ` in "${String(parent.name)}"` : ''} — \`${String(id)}\`.`;
+});
+exports.getTestCase = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const c = await findDoc(client, exports.TM.Case, args.caseId, 'Test case');
+    const suite = await client.findOne(exports.TM.Suite, { _id: c.attachedTo });
+    const people = await (0, people_1.peopleNames)(client);
+    const results = await client.findAll(exports.TM.Result, { testCase: c._id }, { sort: { modifiedOn: core_1.SortingOrder.Descending }, limit: 5 });
+    const lines = [
+        `## ${String(c.name)}`,
+        '',
+        `**Suite:** ${String(suite?.name ?? '—')} · **Type:** ${(0, exports.name)(exports.CASE_TYPES, c.type)} · **Priority:** ${(0, exports.name)(exports.CASE_PRIORITIES, c.priority)} · **Status:** ${(0, exports.name)(exports.CASE_STATUSES, c.status)}`,
+        `**Assignee:** ${c.assignee != null ? people.get(c.assignee) ?? '?' : '—'} · **Id:** \`${String(c._id)}\``,
+        '',
+        '### Steps / description',
+        (await (0, content_1.readMarkup)(args.workspace, c.description)) || '_(empty)_'
+    ];
+    if (results.length > 0) {
+        lines.push('', '### Latest results');
+        for (const r of results) {
+            const run = await client.findOne(exports.TM.Run, { _id: r.attachedTo });
+            lines.push(`- ${(0, exports.name)(exports.RESULT_STATUSES, r.status)} in run "${String(run?.name ?? '?')}" (${(0, format_1.formatDate)(r.modifiedOn)})`);
+        }
+    }
+    return lines.join('\n');
+});
+exports.createTestCase = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const project = await findProject(client, args.project);
+    const suite = await findSuite(client, project, args.suite);
+    const assignee = args.assignee != null ? (await (0, people_1.findPerson)(client, args.assignee))._id : null;
+    const id = await client.addCollection(exports.TM.Case, project._id, suite._id, exports.TM.Suite, 'testCases', {
+        name: args.name,
+        description: args.description != null && args.description !== '' ? await (0, content_1.writeMarkup)(args.workspace, 'testcase', args.description) : null,
+        type: (0, exports.idx)(exports.CASE_TYPES, args.type ?? 'Functional'),
+        priority: (0, exports.idx)(exports.CASE_PRIORITIES, args.priority ?? 'Medium'),
+        status: (0, exports.idx)(exports.CASE_STATUSES, args.status ?? 'Draft'),
+        assignee,
+        attachments: 0
+    });
+    return `✅ Test case **${args.name}** created in "${String(suite.name)}" — \`${String(id)}\`.`;
+});
+exports.updateTestCase = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const c = await findDoc(client, exports.TM.Case, args.caseId, 'Test case');
+    const update = {};
+    if (args.name != null)
+        update.name = args.name;
+    if (args.description != null)
+        update.description = await (0, content_1.writeMarkup)(args.workspace, 'testcase', args.description);
+    if (args.type != null)
+        update.type = (0, exports.idx)(exports.CASE_TYPES, args.type);
+    if (args.priority != null)
+        update.priority = (0, exports.idx)(exports.CASE_PRIORITIES, args.priority);
+    if (args.status != null)
+        update.status = (0, exports.idx)(exports.CASE_STATUSES, args.status);
+    if (args.assignee !== undefined)
+        update.assignee = args.assignee != null ? (await (0, people_1.findPerson)(client, args.assignee))._id : null;
+    if (Object.keys(update).length === 0)
+        throw new Error('Nothing to change.');
+    await client.updateCollection(exports.TM.Case, c.space, c._id, c.attachedTo, exports.TM.Suite, 'testCases', update);
+    return `✅ Test case **${String(args.name ?? c.name)}** updated: ${Object.keys(update).join(', ')}.`;
+});
+exports.deleteTestCase = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const c = await findDoc(client, exports.TM.Case, args.caseId, 'Test case');
+    await client.removeCollection(exports.TM.Case, c.space, c._id, c.attachedTo, exports.TM.Suite, 'testCases');
+    return `✅ Test case **${String(c.name)}** deleted.`;
+});
+/** Cases selected by ids and/or suites (including nested suites). */
+async function selectCases(client, project, caseIds, suites) {
+    const out = new Map();
+    for (const id of caseIds ?? []) {
+        const c = await findDoc(client, exports.TM.Case, id, 'Test case');
+        if (c.space !== project._id)
+            throw new Error(`Test case '${id}' belongs to another project.`);
+        out.set(c._id, c);
+    }
+    if ((suites ?? []).length > 0) {
+        const all = await client.findAll(exports.TM.Suite, { space: project._id });
+        let level = await Promise.all((suites ?? []).map(async (s) => (await findSuite(client, project, s))._id));
+        const ids = new Set(level);
+        while (level.length > 0) {
+            level = all.filter((s) => level.includes(s.parent) && !ids.has(s._id)).map((s) => s._id);
+            for (const l of level)
+                ids.add(l);
+        }
+        const cases = await client.findAll(exports.TM.Case, { space: project._id, attachedTo: { $in: [...ids] } });
+        for (const c of cases)
+            out.set(c._id, c);
+    }
+    return [...out.values()];
+}
+exports.listTestPlans = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const project = await findProject(client, args.project);
+    const plans = await client.findAll(exports.TM.Plan, { space: project._id });
+    if (plans.length === 0)
+        return `No test plans in ${String(project.name)}.`;
+    const lines = [];
+    for (const p of plans) {
+        const items = await client.findAll(exports.TM.PlanItem, { attachedTo: p._id });
+        lines.push(`- **${String(p.name)}** — ${items.length} case(s) — \`${String(p._id)}\``);
+    }
+    return `## Test plans in ${String(project.name)} (${plans.length})\n\n${lines.join('\n')}`;
+});
+exports.createTestPlan = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const project = await findProject(client, args.project);
+    const cases = await selectCases(client, project, args.caseIds, args.suites);
+    if (cases.length === 0)
+        throw new Error('No test cases selected (caseIds or suites).');
+    const ops = client.apply?.() ?? client;
+    const id = await ops.createDoc(exports.TM.Plan, project._id, { name: args.name, description: null });
+    for (const c of cases) {
+        await ops.addCollection(exports.TM.PlanItem, project._id, id, exports.TM.Plan, 'items', { testCase: c._id, testSuite: c.attachedTo, assignee: c.assignee ?? null });
+    }
+    if (ops !== client)
+        await ops.commit();
+    return `✅ Test plan **${args.name}** with ${cases.length} case(s) — \`${String(id)}\`.`;
+});
+exports.createTestRun = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const project = await findProject(client, args.project);
+    let cases = await selectCases(client, project, args.caseIds, args.suites);
+    if (args.plan != null) {
+        const plans = await client.findAll(exports.TM.Plan, { space: project._id });
+        const plan = plans.find((p) => p._id === args.plan || String(p.name).toLowerCase() === args.plan.toLowerCase());
+        if (plan == null)
+            throw new Error(`Test plan '${args.plan}' not found.`);
+        const items = await client.findAll(exports.TM.PlanItem, { attachedTo: plan._id });
+        const fromPlan = await Promise.all(items.map(async (i) => await client.findOne(exports.TM.Case, { _id: i.testCase })));
+        cases = [...new Map([...cases, ...fromPlan.filter((c) => c != null)].map((c) => [c._id, c])).values()];
+    }
+    if (cases.length === 0)
+        throw new Error('No test cases selected (plan, suites or caseIds).');
+    const dueDate = args.dueDate != null ? new Date(args.dueDate).getTime() : undefined;
+    if (dueDate != null && Number.isNaN(dueDate))
+        throw new Error(`Invalid dueDate '${args.dueDate}'.`);
+    const ops = client.apply?.() ?? client;
+    const id = await ops.createDoc(exports.TM.Run, project._id, { name: args.name, description: null, ...(dueDate != null ? { dueDate } : {}) });
+    for (const c of cases) {
+        await ops.addCollection(exports.TM.Result, project._id, id, exports.TM.Run, 'results', { name: c.name, testCase: c._id, testSuite: c.attachedTo, description: null, status: (0, exports.idx)(exports.RESULT_STATUSES, 'Untested'), assignee: c.assignee ?? null });
+    }
+    if (ops !== client)
+        await ops.commit();
+    return `✅ Test run **${args.name}** started with ${cases.length} case(s) — \`${String(id)}\`. Record results with set_test_result.`;
+});
+exports.listTestRuns = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const project = await findProject(client, args.project);
+    const runs = await client.findAll(exports.TM.Run, { space: project._id }, { sort: { modifiedOn: core_1.SortingOrder.Descending }, limit: args.limit });
+    if (runs.length === 0)
+        return `No test runs in ${String(project.name)}.`;
+    const lines = [];
+    for (const r of runs) {
+        const results = await client.findAll(exports.TM.Result, { attachedTo: r._id });
+        const counts = exports.RESULT_STATUSES.map((s, i) => [s, results.filter((x) => (x.status ?? 0) === i).length]).filter(([, n]) => n > 0);
+        lines.push(`- **${String(r.name)}** — ${counts.map(([s, n]) => `${n} ${s}`).join(', ') || 'empty'}${r.dueDate != null ? ` · due ${(0, format_1.formatDate)(r.dueDate)}` : ''} — \`${String(r._id)}\``);
+    }
+    return `## Test runs in ${String(project.name)} (${runs.length})\n\n${lines.join('\n')}`;
+});
+exports.getTestRun = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const run = await findDoc(client, exports.TM.Run, args.runId, 'Test run');
+    const results = await client.findAll(exports.TM.Result, { attachedTo: run._id });
+    const people = await (0, people_1.peopleNames)(client);
+    const lines = results.sort((a, b) => String(a.name).localeCompare(String(b.name))).map((r) => `- ${(0, exports.name)(exports.RESULT_STATUSES, r.status ?? 0)} — **${String(r.name)}**${r.assignee != null ? ` · @${people.get(r.assignee) ?? '?'}` : ''} — \`${String(r._id)}\``);
+    const done = results.filter((r) => (r.status ?? 0) !== 0).length;
+    return `## Run: ${String(run.name)} (${done}/${results.length} tested)\n\n${lines.join('\n')}`;
+});
+exports.setTestResult = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    let result = await client.findOne(exports.TM.Result, { _id: args.result });
+    if (result == null && args.runId != null) {
+        const all = await client.findAll(exports.TM.Result, { attachedTo: args.runId });
+        const hits = all.filter((r) => r.testCase === args.result || String(r.name).toLowerCase() === args.result.toLowerCase());
+        if (hits.length > 1)
+            throw new Error(`'${args.result}' matches several results in this run — use the result id.`);
+        result = hits[0];
+    }
+    if (result == null)
+        throw new Error(`Test result '${args.result}' not found (pass a result id, or runId plus case id/name).`);
+    const update = { status: (0, exports.idx)(exports.RESULT_STATUSES, args.status) };
+    if (args.comment != null)
+        update.description = await (0, content_1.writeMarkup)(args.workspace, 'testresult', args.comment);
+    if (args.assignee !== undefined)
+        update.assignee = args.assignee != null ? (await (0, people_1.findPerson)(client, args.assignee))._id : null;
+    await client.updateCollection(exports.TM.Result, result.space, result._id, result.attachedTo, exports.TM.Run, 'results', update);
+    return `✅ **${String(result.name)}**: ${args.status}${args.comment != null ? ' (with comment)' : ''}.`;
+});
+exports.updateTestSuite = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const project = await findProject(client, args.project);
+    const suite = await findSuite(client, project, args.suite);
+    const update = {};
+    if (args.name != null)
+        update.name = args.name;
+    if (args.description != null)
+        update.description = args.description;
+    if (args.parent !== undefined) {
+        if (args.parent == null)
+            update.parent = exports.TM.NoParent;
+        else {
+            const parent = await findSuite(client, project, args.parent);
+            const all = await client.findAll(exports.TM.Suite, { space: project._id });
+            for (let p = parent; p != null; p = all.find((s) => s._id === p.parent)) {
+                if (p._id === suite._id)
+                    throw new Error('A suite cannot move into itself or one of its sub-suites.');
+            }
+            update.parent = parent._id;
+        }
+    }
+    if (Object.keys(update).length === 0)
+        throw new Error('Nothing to change.');
+    await client.updateDoc(exports.TM.Suite, suite.space, suite._id, update);
+    return `✅ Suite **${String(args.name ?? suite.name)}** updated: ${Object.keys(update).join(', ')}.`;
+});
+exports.deleteTestSuite = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const project = await findProject(client, args.project);
+    const suite = await findSuite(client, project, args.suite);
+    const all = await client.findAll(exports.TM.Suite, { space: project._id });
+    const ids = [suite._id];
+    for (let i = 0; i < ids.length; i++)
+        ids.push(...all.filter((s) => s.parent === ids[i]).map((s) => s._id));
+    const cases = await client.findAll(exports.TM.Case, { space: project._id, attachedTo: { $in: ids } });
+    if ((ids.length > 1 || cases.length > 0) && args.recursive !== true)
+        throw new Error(`Suite '${String(suite.name)}' holds ${ids.length - 1} sub-suite(s) and ${cases.length} case(s) — pass recursive: true to delete them too.`);
+    for (const c of cases)
+        await client.removeCollection(exports.TM.Case, c.space, c._id, c.attachedTo, exports.TM.Suite, 'testCases');
+    for (const id of ids.reverse())
+        await client.removeDoc(exports.TM.Suite, project._id, id);
+    return `🗑️ Suite **${String(suite.name)}** deleted${ids.length > 1 || cases.length > 0 ? ` with ${ids.length - 1} sub-suite(s) and ${cases.length} case(s)` : ''}.`;
+});
+exports.updateTestRun = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const run = await findDoc(client, exports.TM.Run, args.runId, 'Test run');
+    const update = {};
+    if (args.name != null)
+        update.name = args.name;
+    if (args.dueDate !== undefined) {
+        const t = args.dueDate != null ? new Date(args.dueDate).getTime() : null;
+        if (t != null && Number.isNaN(t))
+            throw new Error(`Invalid dueDate '${String(args.dueDate)}'.`);
+        update.dueDate = t;
+    }
+    if (args.description != null)
+        update.description = await (0, content_1.writeMarkup)(args.workspace, 'testrun', args.description);
+    if (Object.keys(update).length === 0)
+        throw new Error('Nothing to change.');
+    await client.updateDoc(exports.TM.Run, run.space, run._id, update);
+    return `✅ Run **${String(args.name ?? run.name)}** updated: ${Object.keys(update).join(', ')}.`;
+});
+exports.deleteTestRun = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const run = await findDoc(client, exports.TM.Run, args.runId, 'Test run');
+    const results = await client.findAll(exports.TM.Result, { attachedTo: run._id });
+    for (const r of results)
+        await client.removeCollection(exports.TM.Result, r.space, r._id, run._id, exports.TM.Run, 'results');
+    await client.removeDoc(exports.TM.Run, run.space, run._id);
+    return `🗑️ Run **${String(run.name)}** deleted with ${results.length} result(s).`;
+});
+exports.deleteTestPlan = (0, errors_1.wrapToolHandler)(async (args) => {
+    const client = await (0, connection_1.getConnection)(args.workspace);
+    const project = await findProject(client, args.project);
+    const plans = await client.findAll(exports.TM.Plan, { space: project._id });
+    const plan = plans.find((p) => p._id === args.plan || String(p.name).toLowerCase() === args.plan.toLowerCase());
+    if (plan == null)
+        throw new Error(`Test plan '${args.plan}' not found.`);
+    const items = await client.findAll(exports.TM.PlanItem, { attachedTo: plan._id });
+    for (const i of items)
+        await client.removeCollection(exports.TM.PlanItem, i.space, i._id, plan._id, exports.TM.Plan, 'items');
+    await client.removeDoc(exports.TM.Plan, plan.space, plan._id);
+    return `🗑️ Test plan **${String(plan.name)}** deleted (${items.length} item(s); runs made from it stay).`;
+});
+//# sourceMappingURL=testing.js.map