npm - @testchimp/cli - Versions diffs - 0.1.17 → 0.1.19 - Mend

@testchimp/cli 0.1.17 → 0.1.19

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/cli/program.js CHANGED Viewed

@@ -673,6 +673,22 @@ export function buildCliProgram() {
         const out = await runTool("get-release", { version: String(merged.version).trim() }, { postMcp });
         console.log(out);
     });
+    program
+        .command("get-release-details")
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-release-details").description)
+        .addOption(jsonInputOption())
+        .option("--version <version>", "Release version / label (McpGetReleaseDetailsRequest.version)")
+        .action(async (opts) => {
+        const body = {};
+        if (opts.version)
+            body.version = String(opts.version);
+        const merged = mergeBodies(body, opts.jsonInput);
+        if (!merged.version || String(merged.version).trim() === "") {
+            throw new Error("version is required (--version or --json-input {\"version\":\"...\"})");
+        }
+        const out = await runTool("get-release-details", { version: String(merged.version).trim() }, { postMcp });
+        console.log(out);
+    });
     program
         .command("get-security-scan-config")
         .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-security-scan-config").description)
@@ -833,6 +849,54 @@ export function buildCliProgram() {
         const out = await runTool("mark-semantic-tests-distinct", merged, { postMcp });
         console.log(out);
     });
+    program
+        .command("get-requirement-quality-report")
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-requirement-quality-report").description)
+        .addOption(jsonInputOption())
+        .option("--subject-type <STORY|SCENARIO>", "STORY for US-<n>, SCENARIO for TS-<n>")
+        .option("--subject-entity-id <id>", "Platform subject entity id")
+        .option("--ordinal-id <n>", "Numeric part of US-<n> or TS-<n>")
+        .action(async (opts) => {
+        const body = {};
+        if (opts.subjectType)
+            body.subjectType = String(opts.subjectType).trim();
+        if (opts.subjectEntityId)
+            body.subjectEntityId = String(opts.subjectEntityId).trim();
+        if (opts.ordinalId != null)
+            body.ordinalId = Number(opts.ordinalId);
+        const merged = mergeBodies(body, opts.jsonInput);
+        if (!merged.subjectType || String(merged.subjectType).trim() === "") {
+            throw new Error("subjectType is required (STORY | SCENARIO)");
+        }
+        const out = await runTool("get-requirement-quality-report", {
+            subjectType: String(merged.subjectType).trim(),
+            ...(merged.subjectEntityId ? { subjectEntityId: String(merged.subjectEntityId).trim() } : {}),
+            ...(merged.ordinalId != null ? { ordinalId: Number(merged.ordinalId) } : {}),
+        }, { postMcp });
+        console.log(out);
+    });
+    program
+        .command("report-requirement-quality-findings")
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "report-requirement-quality-findings").description)
+        .addOption(jsonInputOption())
+        .option("--report-file <path>", "Path to RequirementQualityReport JSON (camelCase)")
+        .option("--subject-type <STORY|SCENARIO>", "Merge into report.subject when resolving entity id")
+        .option("--subject-entity-id <id>", "Platform subject entity id (story DB id or scenario UUID)")
+        .option("--ordinal-id <n>", "US-<n> or TS-<n> numeric id; resolves subjectEntityId via get-report")
+        .action(async (opts) => {
+        const body = {};
+        if (opts.reportFile)
+            body.reportFile = String(opts.reportFile);
+        if (opts.subjectType)
+            body.subjectType = String(opts.subjectType).trim();
+        if (opts.subjectEntityId)
+            body.subjectEntityId = String(opts.subjectEntityId).trim();
+        if (opts.ordinalId != null)
+            body.ordinalId = Number(opts.ordinalId);
+        const merged = mergeBodies(body, opts.jsonInput);
+        const out = await runTool("report-requirement-quality-findings", merged, { postMcp });
+        console.log(out);
+    });
     program.on("--help", () => {
         /* default */
     });

package/dist/core/schemas.d.ts CHANGED Viewed

@@ -647,6 +647,9 @@ export declare const listScreenStatesInput: z.ZodObject<{
 export declare const getReleaseInput: z.ZodObject<{
     version: z.ZodString;
 }, z.core.$strip>;
+export declare const getReleaseDetailsInput: z.ZodObject<{
+    version: z.ZodString;
+}, z.core.$strip>;
 export declare const getSecurityScanConfigInput: z.ZodObject<{
     id: z.ZodString;
 }, z.core.$strip>;
@@ -708,3 +711,307 @@ export declare const markSemanticTestsDistinctInput: z.ZodObject<{
         testName: z.ZodString;
     }, z.core.$strip>;
 }, z.core.$strip>;
+/** RequirementSubjectType — proto enum names (JsonFormat camelCase on wire). */
+export declare const requirementSubjectTypeSchema: z.ZodEnum<{
+    STORY: "STORY";
+    SCENARIO: "SCENARIO";
+}>;
+/** RequirementFindingSeverity — proto enum names. */
+export declare const requirementFindingSeveritySchema: z.ZodEnum<{
+    CRITICAL: "CRITICAL";
+    MAJOR: "MAJOR";
+    MINOR: "MINOR";
+}>;
+/** RequirementFindingUserState — proto enum names. */
+export declare const requirementFindingUserStateSchema: z.ZodEnum<{
+    ACTIVE: "ACTIVE";
+    IGNORED: "IGNORED";
+    APPLIED: "APPLIED";
+}>;
+/** RequirementQualityReportSource — proto enum names. */
+export declare const requirementQualityReportSourceSchema: z.ZodEnum<{
+    CLOUD: "CLOUD";
+    LOCAL_AGENT: "LOCAL_AGENT";
+}>;
+/** SuggestedFixKind — proto enum names. */
+export declare const suggestedFixKindSchema: z.ZodEnum<{
+    OTHER: "OTHER";
+    REWORD_EXCERPT: "REWORD_EXCERPT";
+    REWRITE_SECTION: "REWRITE_SECTION";
+    ADD_CONTENT: "ADD_CONTENT";
+    CREATE_SCENARIO: "CREATE_SCENARIO";
+    CREATE_STORY: "CREATE_STORY";
+    DELETE_SCENARIO: "DELETE_SCENARIO";
+    DELETE_STORY: "DELETE_STORY";
+    LINK_OR_UNLINK: "LINK_OR_UNLINK";
+}>;
+/** TextReplacement (requirement_quality.proto) — camelCase wire shape. */
+export declare const textReplacementSchema: z.ZodObject<{
+    originalExcerpt: z.ZodOptional<z.ZodString>;
+    suggestedText: z.ZodOptional<z.ZodString>;
+    contextBefore: z.ZodOptional<z.ZodString>;
+    contextAfter: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** SuggestedFix (requirement_quality.proto). isDestructive is derived server-side from kind. */
+export declare const suggestedFixSchema: z.ZodObject<{
+    kind: z.ZodOptional<z.ZodEnum<{
+        OTHER: "OTHER";
+        REWORD_EXCERPT: "REWORD_EXCERPT";
+        REWRITE_SECTION: "REWRITE_SECTION";
+        ADD_CONTENT: "ADD_CONTENT";
+        CREATE_SCENARIO: "CREATE_SCENARIO";
+        CREATE_STORY: "CREATE_STORY";
+        DELETE_SCENARIO: "DELETE_SCENARIO";
+        DELETE_STORY: "DELETE_STORY";
+        LINK_OR_UNLINK: "LINK_OR_UNLINK";
+    }>>;
+    isDestructive: z.ZodOptional<z.ZodBoolean>;
+    targetEntityType: z.ZodOptional<z.ZodString>;
+    targetOrdinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    summary: z.ZodOptional<z.ZodString>;
+    agentPrompt: z.ZodOptional<z.ZodString>;
+    replacements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        originalExcerpt: z.ZodOptional<z.ZodString>;
+        suggestedText: z.ZodOptional<z.ZodString>;
+        contextBefore: z.ZodOptional<z.ZodString>;
+        contextAfter: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    rationale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** RequirementQualityFinding (requirement_quality.proto). */
+export declare const requirementQualityFindingSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    fingerprint: z.ZodOptional<z.ZodString>;
+    analyst: z.ZodOptional<z.ZodString>;
+    severity: z.ZodOptional<z.ZodEnum<{
+        CRITICAL: "CRITICAL";
+        MAJOR: "MAJOR";
+        MINOR: "MINOR";
+    }>>;
+    confidence: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    title: z.ZodOptional<z.ZodString>;
+    detail: z.ZodOptional<z.ZodString>;
+    suggestedFix: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodEnum<{
+            OTHER: "OTHER";
+            REWORD_EXCERPT: "REWORD_EXCERPT";
+            REWRITE_SECTION: "REWRITE_SECTION";
+            ADD_CONTENT: "ADD_CONTENT";
+            CREATE_SCENARIO: "CREATE_SCENARIO";
+            CREATE_STORY: "CREATE_STORY";
+            DELETE_SCENARIO: "DELETE_SCENARIO";
+            DELETE_STORY: "DELETE_STORY";
+            LINK_OR_UNLINK: "LINK_OR_UNLINK";
+        }>>;
+        isDestructive: z.ZodOptional<z.ZodBoolean>;
+        targetEntityType: z.ZodOptional<z.ZodString>;
+        targetOrdinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        summary: z.ZodOptional<z.ZodString>;
+        agentPrompt: z.ZodOptional<z.ZodString>;
+        replacements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            originalExcerpt: z.ZodOptional<z.ZodString>;
+            suggestedText: z.ZodOptional<z.ZodString>;
+            contextBefore: z.ZodOptional<z.ZodString>;
+            contextAfter: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        rationale: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    userState: z.ZodOptional<z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        IGNORED: "IGNORED";
+        APPLIED: "APPLIED";
+    }>>;
+}, z.core.$strip>;
+/** RequirementQualityMetrics (requirement_quality.proto) — scores 0-100, counts among ACTIVE findings. */
+export declare const requirementQualityMetricsSchema: z.ZodObject<{
+    overall: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    clarity: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    completeness: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    testability: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    consistency: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    ambiguityRisk: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    scenarioCoverage: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    criticalCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    majorCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    minorCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+/** RequirementQualitySubject (requirement_quality.proto). subjectEntityId is the platform-internal id. */
+export declare const requirementQualitySubjectSchema: z.ZodObject<{
+    subjectType: z.ZodOptional<z.ZodEnum<{
+        STORY: "STORY";
+        SCENARIO: "SCENARIO";
+    }>>;
+    subjectEntityId: z.ZodOptional<z.ZodString>;
+    ordinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** RequirementQualityReport (requirement_quality.proto) — full upload body shape. */
+export declare const requirementQualityReportSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodObject<{
+        subjectType: z.ZodOptional<z.ZodEnum<{
+            STORY: "STORY";
+            SCENARIO: "SCENARIO";
+        }>>;
+        subjectEntityId: z.ZodOptional<z.ZodString>;
+        ordinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    source: z.ZodOptional<z.ZodEnum<{
+        CLOUD: "CLOUD";
+        LOCAL_AGENT: "LOCAL_AGENT";
+    }>>;
+    metrics: z.ZodOptional<z.ZodObject<{
+        overall: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        clarity: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        completeness: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        testability: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        consistency: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        ambiguityRisk: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        scenarioCoverage: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        criticalCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        majorCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        minorCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>>;
+    findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        fingerprint: z.ZodOptional<z.ZodString>;
+        analyst: z.ZodOptional<z.ZodString>;
+        severity: z.ZodOptional<z.ZodEnum<{
+            CRITICAL: "CRITICAL";
+            MAJOR: "MAJOR";
+            MINOR: "MINOR";
+        }>>;
+        confidence: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        title: z.ZodOptional<z.ZodString>;
+        detail: z.ZodOptional<z.ZodString>;
+        suggestedFix: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodEnum<{
+                OTHER: "OTHER";
+                REWORD_EXCERPT: "REWORD_EXCERPT";
+                REWRITE_SECTION: "REWRITE_SECTION";
+                ADD_CONTENT: "ADD_CONTENT";
+                CREATE_SCENARIO: "CREATE_SCENARIO";
+                CREATE_STORY: "CREATE_STORY";
+                DELETE_SCENARIO: "DELETE_SCENARIO";
+                DELETE_STORY: "DELETE_STORY";
+                LINK_OR_UNLINK: "LINK_OR_UNLINK";
+            }>>;
+            isDestructive: z.ZodOptional<z.ZodBoolean>;
+            targetEntityType: z.ZodOptional<z.ZodString>;
+            targetOrdinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            summary: z.ZodOptional<z.ZodString>;
+            agentPrompt: z.ZodOptional<z.ZodString>;
+            replacements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                originalExcerpt: z.ZodOptional<z.ZodString>;
+                suggestedText: z.ZodOptional<z.ZodString>;
+                contextBefore: z.ZodOptional<z.ZodString>;
+                contextAfter: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            rationale: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        userState: z.ZodOptional<z.ZodEnum<{
+            ACTIVE: "ACTIVE";
+            IGNORED: "IGNORED";
+            APPLIED: "APPLIED";
+        }>>;
+    }, z.core.$strip>>>;
+    createdAtMillis: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    jobId: z.ZodOptional<z.ZodString>;
+    contentFingerprint: z.ZodOptional<z.ZodString>;
+    scoresUpdatedAtMillis: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const getRequirementQualityReportInput: z.ZodObject<{
+    subjectType: z.ZodEnum<{
+        STORY: "STORY";
+        SCENARIO: "SCENARIO";
+    }>;
+    subjectEntityId: z.ZodOptional<z.ZodString>;
+    ordinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const reportRequirementQualityFindingsInput: z.ZodObject<{
+    report: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodObject<{
+            subjectType: z.ZodOptional<z.ZodEnum<{
+                STORY: "STORY";
+                SCENARIO: "SCENARIO";
+            }>>;
+            subjectEntityId: z.ZodOptional<z.ZodString>;
+            ordinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        source: z.ZodOptional<z.ZodEnum<{
+            CLOUD: "CLOUD";
+            LOCAL_AGENT: "LOCAL_AGENT";
+        }>>;
+        metrics: z.ZodOptional<z.ZodObject<{
+            overall: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            clarity: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            completeness: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            testability: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            consistency: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            ambiguityRisk: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            scenarioCoverage: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            criticalCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            majorCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            minorCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        }, z.core.$strip>>;
+        findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            fingerprint: z.ZodOptional<z.ZodString>;
+            analyst: z.ZodOptional<z.ZodString>;
+            severity: z.ZodOptional<z.ZodEnum<{
+                CRITICAL: "CRITICAL";
+                MAJOR: "MAJOR";
+                MINOR: "MINOR";
+            }>>;
+            confidence: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            title: z.ZodOptional<z.ZodString>;
+            detail: z.ZodOptional<z.ZodString>;
+            suggestedFix: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodOptional<z.ZodEnum<{
+                    OTHER: "OTHER";
+                    REWORD_EXCERPT: "REWORD_EXCERPT";
+                    REWRITE_SECTION: "REWRITE_SECTION";
+                    ADD_CONTENT: "ADD_CONTENT";
+                    CREATE_SCENARIO: "CREATE_SCENARIO";
+                    CREATE_STORY: "CREATE_STORY";
+                    DELETE_SCENARIO: "DELETE_SCENARIO";
+                    DELETE_STORY: "DELETE_STORY";
+                    LINK_OR_UNLINK: "LINK_OR_UNLINK";
+                }>>;
+                isDestructive: z.ZodOptional<z.ZodBoolean>;
+                targetEntityType: z.ZodOptional<z.ZodString>;
+                targetOrdinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                summary: z.ZodOptional<z.ZodString>;
+                agentPrompt: z.ZodOptional<z.ZodString>;
+                replacements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    originalExcerpt: z.ZodOptional<z.ZodString>;
+                    suggestedText: z.ZodOptional<z.ZodString>;
+                    contextBefore: z.ZodOptional<z.ZodString>;
+                    contextAfter: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                rationale: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            userState: z.ZodOptional<z.ZodEnum<{
+                ACTIVE: "ACTIVE";
+                IGNORED: "IGNORED";
+                APPLIED: "APPLIED";
+            }>>;
+        }, z.core.$strip>>>;
+        createdAtMillis: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        jobId: z.ZodOptional<z.ZodString>;
+        contentFingerprint: z.ZodOptional<z.ZodString>;
+        scoresUpdatedAtMillis: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>>;
+    reportFile: z.ZodOptional<z.ZodString>;
+    subjectType: z.ZodOptional<z.ZodEnum<{
+        STORY: "STORY";
+        SCENARIO: "SCENARIO";
+    }>>;
+    subjectEntityId: z.ZodOptional<z.ZodString>;
+    ordinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;

package/dist/core/schemas.js CHANGED Viewed

@@ -324,6 +324,10 @@ export const getReleaseInput = z.object({
     /** Release catalog version / label — maps to McpGetReleaseRequest.version */
     version: z.string().min(1),
 });
+export const getReleaseDetailsInput = z.object({
+    /** Release catalog version / label — maps to McpGetReleaseDetailsRequest.version */
+    version: z.string().min(1),
+});
 export const getSecurityScanConfigInput = z.object({
     id: z.string().min(1),
 });
@@ -373,3 +377,126 @@ export const markSemanticTestsDistinctInput = z.object({
     focusTest: testLocatorSchema,
     distinctTest: testLocatorSchema,
 });
+/** RequirementSubjectType — proto enum names (JsonFormat camelCase on wire). */
+export const requirementSubjectTypeSchema = z.enum(["STORY", "SCENARIO"]);
+/** RequirementFindingSeverity — proto enum names. */
+export const requirementFindingSeveritySchema = z.enum(["CRITICAL", "MAJOR", "MINOR"]);
+/** RequirementFindingUserState — proto enum names. */
+export const requirementFindingUserStateSchema = z.enum(["ACTIVE", "IGNORED", "APPLIED"]);
+/** RequirementQualityReportSource — proto enum names. */
+export const requirementQualityReportSourceSchema = z.enum(["CLOUD", "LOCAL_AGENT"]);
+/** SuggestedFixKind — proto enum names. */
+export const suggestedFixKindSchema = z.enum([
+    "REWORD_EXCERPT",
+    "REWRITE_SECTION",
+    "ADD_CONTENT",
+    "CREATE_SCENARIO",
+    "CREATE_STORY",
+    "DELETE_SCENARIO",
+    "DELETE_STORY",
+    "LINK_OR_UNLINK",
+    "OTHER",
+]);
+/** TextReplacement (requirement_quality.proto) — camelCase wire shape. */
+export const textReplacementSchema = z.object({
+    originalExcerpt: z.string().optional(),
+    suggestedText: z.string().optional(),
+    contextBefore: z.string().optional(),
+    contextAfter: z.string().optional(),
+});
+/** SuggestedFix (requirement_quality.proto). isDestructive is derived server-side from kind. */
+export const suggestedFixSchema = z.object({
+    kind: suggestedFixKindSchema.optional(),
+    isDestructive: z.boolean().optional(),
+    /** "STORY" | "SCENARIO" — target of the fix (may differ from the finding's own subject). */
+    targetEntityType: z.string().optional(),
+    targetOrdinalId: z.coerce.number().int().optional(),
+    summary: z.string().optional(),
+    agentPrompt: z.string().optional(),
+    replacements: z.array(textReplacementSchema).optional(),
+    rationale: z.string().optional(),
+});
+/** RequirementQualityFinding (requirement_quality.proto). */
+export const requirementQualityFindingSchema = z.object({
+    id: z.string().optional(),
+    fingerprint: z.string().optional(),
+    analyst: z.string().optional(),
+    severity: requirementFindingSeveritySchema.optional(),
+    confidence: z.coerce.number().int().optional(),
+    title: z.string().optional(),
+    detail: z.string().optional(),
+    suggestedFix: suggestedFixSchema.optional(),
+    /** Omit (defaults ACTIVE server-side) for new findings; set explicitly to carry forward IGNORED/APPLIED. */
+    userState: requirementFindingUserStateSchema.optional(),
+});
+/** RequirementQualityMetrics (requirement_quality.proto) — scores 0-100, counts among ACTIVE findings. */
+export const requirementQualityMetricsSchema = z.object({
+    overall: z.coerce.number().int().optional(),
+    clarity: z.coerce.number().int().optional(),
+    completeness: z.coerce.number().int().optional(),
+    testability: z.coerce.number().int().optional(),
+    consistency: z.coerce.number().int().optional(),
+    ambiguityRisk: z.coerce.number().int().optional(),
+    scenarioCoverage: z.coerce.number().int().optional(),
+    criticalCount: z.coerce.number().int().optional(),
+    majorCount: z.coerce.number().int().optional(),
+    minorCount: z.coerce.number().int().optional(),
+});
+/** RequirementQualitySubject (requirement_quality.proto). subjectEntityId is the platform-internal id. */
+export const requirementQualitySubjectSchema = z.object({
+    subjectType: requirementSubjectTypeSchema.optional(),
+    subjectEntityId: z.string().optional(),
+    ordinalId: z.coerce.number().int().optional(),
+    title: z.string().optional(),
+});
+/** RequirementQualityReport (requirement_quality.proto) — full upload body shape. */
+export const requirementQualityReportSchema = z.object({
+    id: z.string().optional(),
+    projectId: z.string().optional(),
+    subject: requirementQualitySubjectSchema.optional(),
+    source: requirementQualityReportSourceSchema.optional(),
+    metrics: requirementQualityMetricsSchema.optional(),
+    findings: z.array(requirementQualityFindingSchema).optional(),
+    createdAtMillis: z.coerce.number().optional(),
+    jobId: z.string().optional(),
+    contentFingerprint: z.string().optional(),
+    scoresUpdatedAtMillis: z.coerce.number().optional(),
+});
+const requirementSubjectRefinement = (v, ctx) => {
+    const entityId = (v.subjectEntityId ?? "").trim();
+    const ordinal = v.ordinalId;
+    if (entityId === "" && (ordinal == null || ordinal <= 0)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Provide subjectEntityId or ordinalId",
+        });
+    }
+};
+export const getRequirementQualityReportInput = z
+    .object({
+    subjectType: requirementSubjectTypeSchema,
+    subjectEntityId: z.string().optional(),
+    ordinalId: z.coerce.number().int().positive().optional(),
+})
+    .superRefine(requirementSubjectRefinement);
+export const reportRequirementQualityFindingsInput = z
+    .object({
+    /** Full RequirementQualityReport JSON object (camelCase, requirement_quality.proto). */
+    report: requirementQualityReportSchema.optional(),
+    /** Path to RequirementQualityReport JSON file. */
+    reportFile: z.string().optional(),
+    /** Convenience: merged into report.subject when report lacks subjectEntityId. */
+    subjectType: requirementSubjectTypeSchema.optional(),
+    subjectEntityId: z.string().optional(),
+    ordinalId: z.coerce.number().int().positive().optional(),
+})
+    .superRefine((v, ctx) => {
+    const hasReport = v.report != null && Object.keys(v.report).length > 0;
+    const hasFile = (v.reportFile ?? "").trim() !== "";
+    if (!hasReport && !hasFile) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Provide report object, reportFile path, or full body via --json-input",
+        });
+    }
+});

package/dist/core/tools.js CHANGED Viewed

@@ -85,6 +85,43 @@ function listExecutionBody(args) {
         body.offset = args.offset;
     return body;
 }
+function requirementQualitySubjectBody(subjectType, opts) {
+    const body = { subjectType };
+    const entityId = (opts.subjectEntityId ?? "").trim();
+    if (entityId !== "")
+        body.subjectEntityId = entityId;
+    if (opts.ordinalId != null && opts.ordinalId > 0)
+        body.ordinalId = opts.ordinalId;
+    return body;
+}
+/** Resolve platform subjectEntityId from explicit id or get-requirement-quality-report via ordinal. */
+async function resolveRequirementSubjectEntityId(postMcp, subjectType, opts) {
+    const explicit = (opts.subjectEntityId ?? "").trim();
+    if (explicit !== "")
+        return explicit;
+    if (opts.ordinalId == null || opts.ordinalId <= 0) {
+        throw new Error("Provide subjectEntityId or ordinalId");
+    }
+    const json = await postMcp("/api/mcp/get_requirement_quality_report", requirementQualitySubjectBody(subjectType, { ordinalId: opts.ordinalId }));
+    const parsed = JSON.parse(json);
+    const resolved = (parsed.report?.subject?.subjectEntityId ?? "").trim();
+    if (resolved !== "")
+        return resolved;
+    throw new Error(`Cannot resolve subjectEntityId for ${subjectType} ordinal ${opts.ordinalId}. ` +
+        "Provide --subject-entity-id, or confirm the story/scenario ordinal exists in this project " +
+        "(get-requirement-quality-report resolves entity id by ordinal even when no prior report exists).");
+}
+async function loadRequirementQualityReportJson(args) {
+    if (args.report != null && Object.keys(args.report).length > 0) {
+        return { ...args.report };
+    }
+    if (args.reportFile != null && args.reportFile.trim() !== "") {
+        const { readFile } = await import("node:fs/promises");
+        const raw = await readFile(args.reportFile.trim(), "utf8");
+        return JSON.parse(raw);
+    }
+    return {};
+}
 export const TOOL_DEFINITIONS = [
     {
         kebab: "get-requirement-coverage",
@@ -552,6 +589,19 @@ export const TOOL_DEFINITIONS = [
             return postMcp("/api/mcp/get_release", body);
         },
     },
+    {
+        kebab: "get-release-details",
+        description: "Fetch gate-oriented release details for a version/label: scope, per-environment " +
+            "priority×status test stats, open issue stats, scan summaries, and detailed in-scope " +
+            "scenario/issue records (McpGetReleaseDetailsRequest/Response). Pass version (CLI: --version). " +
+            "Use for CI/agent release gating. Authenticated via project API key.",
+        inputSchema: S.getReleaseDetailsInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const body = { version: a.version.trim() };
+            return postMcp("/api/mcp/get_release_details", body);
+        },
+    },
     {
         kebab: "get-security-scan-config",
         description: "Fetch security scan config by scan id (detail.dastCheckConfig / detail.sastCheckConfig / " +
@@ -678,6 +728,54 @@ export const TOOL_DEFINITIONS = [
             });
         },
     },
+    {
+        kebab: "get-requirement-quality-report",
+        description: "Fetch the stored requirement quality report (metrics + findings with user states) for a user story or test scenario. " +
+            "Use before local DeFOSPAM to dedupe: do not re-report findings already IGNORED or APPLIED (match by fingerprint). " +
+            "Pass subjectType STORY|SCENARIO plus subjectEntityId or ordinalId (numeric part of US-<n> / TS-<n>). " +
+            "When no prior report exists, response still includes report.subject with resolved subjectEntityId.",
+        inputSchema: S.getRequirementQualityReportInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            return postMcp("/api/mcp/get_requirement_quality_report", requirementQualitySubjectBody(a.subjectType, {
+                subjectEntityId: a.subjectEntityId,
+                ordinalId: a.ordinalId,
+            }));
+        },
+    },
+    {
+        kebab: "report-requirement-quality-findings",
+        description: "Upload a DeFOSPAM / requirement quality analysis report for a user story or test scenario (local-agent path). " +
+            "Pass full RequirementQualityReport JSON via --report-file or --json-input {\"report\":{...}}. " +
+            "report.subject.subjectEntityId is required; use --subject-type + --ordinal-id to resolve via get-requirement-quality-report, " +
+            "or set subjectEntityId explicitly. Backend merges IGNORED/APPLIED findings carry-forward on re-report.",
+        inputSchema: S.reportRequirementQualityFindingsInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const report = await loadRequirementQualityReportJson(a);
+            const subjectRaw = (report.subject ?? {});
+            const subjectType = (a.subjectType ?? subjectRaw.subjectType);
+            const ordinalId = a.ordinalId ??
+                (typeof subjectRaw.ordinalId === "number" ? subjectRaw.ordinalId : undefined);
+            let subjectEntityId = (a.subjectEntityId ?? (typeof subjectRaw.subjectEntityId === "string" ? subjectRaw.subjectEntityId : "")).trim();
+            if (subjectEntityId === "" && subjectType != null) {
+                subjectEntityId = await resolveRequirementSubjectEntityId(postMcp, subjectType, {
+                    ordinalId,
+                });
+            }
+            if (subjectEntityId === "") {
+                throw new Error("report.subject.subjectEntityId is required (set in report JSON, --subject-entity-id, or resolvable via --ordinal-id)");
+            }
+            const mergedSubject = {
+                ...subjectRaw,
+                ...(subjectType != null ? { subjectType } : {}),
+                subjectEntityId,
+                ...(ordinalId != null ? { ordinalId } : {}),
+            };
+            report.subject = mergedSubject;
+            return postMcp("/api/mcp/report_requirement_quality_findings", { report });
+        },
+    },
 ];
 const TOOL_BY_KEBAB = new Map(TOOL_DEFINITIONS.map((t) => [t.kebab, t]));
 export function getToolDefinition(kebab) {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@testchimp/cli",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "TestChimp CLI and MCP server — coverage, plans, EaaS, TrueCoverage (calls /api/mcp/*)",
   "type": "module",
   "main": "dist/bin/testchimp.js",