dsh-logicprobe 0.4.0 → 0.5.0

package/lib/tool.js

@@ -1,57 +1,57 @@
-import { defineTool } from '@deepseek-ai/dsh-tools';
-import { runVerification } from './engine.js';
-export const LOGICPROBE_VERIFY_TOOL_NAME = 'logicprobe_verify';
-/**
- * Model-visible DSH tool wrapping the bundled TypeScript verification engine.
- * The model passes a LogicModelV1 object; the engine validates it and returns
- * the 14-check report, or an 18-check report when beforeModel is supplied
- * (D1 behavioral preservation, D2 invariant continuity, D3 regression delta,
- * D4 deadlock/liveness regression). This is the dsh-native replacement for
- * hand-filling the Python template shipped in the skill references.
- */
-export const logicProbeVerifyTool = defineTool({
-    name: LOGICPROBE_VERIFY_TOOL_NAME,
-    description: 'Run executable state-machine verification (logicprobe). Takes a LogicModelV1 object with schemaVersion=1, init, states ({id, terminal?}), transitions ({from, event, to, guard?, updates?}), variables?, invariants?, concurrentPairs?, boundaryChecks?, resourcePairs?. Guards are structured ({variable, op, value} | {all} | {any} | {not}); invariants support never-states, var-in-range, and event-before-state. Returns a report with S1-S7 structural checks and A1-A7 adversarial probes including shortest counterexample paths. If beforeModel is provided, also runs D1-D4 before/after regression checks. See skills/logicprobe/references/dsh-model-schema.md.',
-    parameters: {
-        model: {
-            type: 'json',
-            required: true,
-            description: 'LogicModelV1 state machine model to verify.',
-        },
-        maxStates: {
-            type: 'integer',
-            description: 'Maximum runtime states to explore. Default 10000.',
-        },
-        maxPermutationEvents: {
-            type: 'integer',
-            description: 'Maximum event count for A3 order permutation. Default 5.',
-        },
-        beforeModel: {
-            type: 'json',
-            description: 'Optional BEFORE LogicModelV1 state machine model for refactoring/migration regression comparison.',
-        },
-        stateMapping: {
-            type: 'json',
-            description: 'Optional object mapping BEFORE state ids to AFTER state ids. Omit for identity mapping (same state names).',
-        },
-    },
-    output: {
-        schema: {
-            type: 'json',
-            description: 'logicprobe verification report with summary and per-check findings.',
-        },
-        render(_args, value) {
-            return [{ type: 'text', text: JSON.stringify(value, null, 2) }];
-        },
-    },
-    timeoutMs: 10_000,
-    isConcurrencySafe: () => true,
-    async execute(args) {
-        return runVerification(args.model, {
-            maxStates: args.maxStates,
-            maxPermutationEvents: args.maxPermutationEvents,
-            beforeModel: args.beforeModel,
-            stateMapping: args.stateMapping,
-        });
-    },
-});
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { runVerification } from './engine.js';
+export const LOGICPROBE_VERIFY_TOOL_NAME = 'logicprobe_verify';
+/**
+ * Model-visible DSH tool wrapping the bundled TypeScript verification engine.
+ * The model passes a LogicModelV1 object; the engine validates it and returns
+ * the 14-check report, or an 18-check report when beforeModel is supplied
+ * (D1 behavioral preservation, D2 invariant continuity, D3 regression delta,
+ * D4 deadlock/liveness regression). This is the dsh-native replacement for
+ * hand-filling the Python template shipped in the skill references.
+ */
+export const logicProbeVerifyTool = defineTool({
+    name: LOGICPROBE_VERIFY_TOOL_NAME,
+    description: 'Run executable state-machine verification (logicprobe). Takes a LogicModelV1 object with schemaVersion=1, init, states ({id, terminal?}), transitions ({from, event, to, guard?, updates?}), variables?, invariants?, concurrentPairs?, boundaryChecks?, resourcePairs?, idempotentEvents?. Guards are structured ({variable, op, value} | {all} | {any} | {not}); invariants support never-states, var-in-range, event-before-state, leads-to, sequence, and atomicity; variables support monotonic inc/dec. Returns a report with S1-S7 structural checks and A1-A7 adversarial probes including shortest counterexample paths. If beforeModel is provided, also runs D1-D4 before/after regression checks. See skills/logicprobe/references/dsh-model-schema.md.',
+    parameters: {
+        model: {
+            type: 'json',
+            required: true,
+            description: 'LogicModelV1 state machine model to verify.',
+        },
+        maxStates: {
+            type: 'integer',
+            description: 'Maximum runtime states to explore. Default 10000.',
+        },
+        maxPermutationEvents: {
+            type: 'integer',
+            description: 'Maximum event count for A3 order permutation. Default 5.',
+        },
+        beforeModel: {
+            type: 'json',
+            description: 'Optional BEFORE LogicModelV1 state machine model for refactoring/migration regression comparison.',
+        },
+        stateMapping: {
+            type: 'json',
+            description: 'Optional object mapping BEFORE state ids to AFTER state ids. Omit for identity mapping (same state names).',
+        },
+    },
+    output: {
+        schema: {
+            type: 'json',
+            description: 'logicprobe verification report with summary and per-check findings.',
+        },
+        render(_args, value) {
+            return [{ type: 'text', text: JSON.stringify(value, null, 2) }];
+        },
+    },
+    timeoutMs: 10_000,
+    isConcurrencySafe: () => true,
+    async execute(args) {
+        return runVerification(args.model, {
+            maxStates: args.maxStates,
+            maxPermutationEvents: args.maxPermutationEvents,
+            beforeModel: args.beforeModel,
+            stateMapping: args.stateMapping,
+        });
+    },
+});

package/lib/types/concurrency-tool.d.ts

@@ -0,0 +1,8 @@
+export declare const LOGICPROBE_CONCURRENCY_SCAN_TOOL_NAME = "logicprobe_concurrency_scan";
+/**
+ * Model-visible DSH tool that mines design documents/plans for concurrency-related
+ * claims and risk keywords. It does not prove concurrency safety; it flags terms
+ * such as "thread-safe", "lock-free", "race condition", "atomic", "mutex", etc.,
+ * so the model can either provide dedicated evidence or mark the claim unverified.
+ */
+export declare const logicProbeConcurrencyScanTool: import("@deepseek-ai/dsh-tools").ToolDefinition;

package/lib/types/concurrency.d.ts

@@ -0,0 +1,20 @@
+export interface ConcurrencyFinding {
+    code: 'CONCURRENCY_KEYWORD' | 'CONCURRENCY_ABSOLUTE_CLAIM';
+    severity: 'warning' | 'error';
+    message: string;
+    line?: number;
+    snippet?: string;
+    keyword: string;
+}
+export interface ConcurrencyScanReport {
+    ok: boolean;
+    findings: ConcurrencyFinding[];
+    summary: {
+        lines: number;
+        keywords: number;
+        absoluteClaims: number;
+        warnings: number;
+        errors: number;
+    };
+}
+export declare function runConcurrencyScan(text: string): ConcurrencyScanReport;

package/lib/types/data-engine.d.ts

@@ -0,0 +1,199 @@
+import type { CheckResult } from './engine.js';
+export declare const DATA_ENGINE_SCHEMA_VERSION = 1;
+export type DataValue = number | string | boolean | null;
+export type DataType = 'string' | 'integer' | 'number' | 'boolean' | 'uuid' | 'date' | 'datetime' | 'timestamp' | 'json' | 'enum' | 'array' | 'object' | 'binary';
+export interface FieldSpec {
+    name: string;
+    type: DataType | string;
+    required?: boolean;
+    unique?: boolean;
+    nullable?: boolean;
+    default?: DataValue;
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    enum?: DataValue[];
+    ref?: string;
+    items?: FieldSpec;
+    monotonic?: 'inc' | 'dec';
+}
+export interface EntitySpec {
+    name: string;
+    fields: FieldSpec[];
+    primaryKey?: string[];
+    uniqueKeys?: string[][];
+    indexes?: string[][];
+}
+export interface RelationshipSpec {
+    name?: string;
+    fromEntity: string;
+    fromField: string;
+    toEntity: string;
+    toField?: string;
+    onDelete?: 'cascade' | 'restrict' | 'set-null' | 'no-action';
+}
+export type DataInvariantSpec = {
+    id: string;
+    description: string;
+    kind: 'field-required';
+    entity: string;
+    field: string;
+} | {
+    id: string;
+    description: string;
+    kind: 'unique';
+    entity: string;
+    fields: string[];
+} | {
+    id: string;
+    description: string;
+    kind: 'referential-integrity';
+    entity: string;
+    field: string;
+    refEntity: string;
+    refField?: string;
+} | {
+    id: string;
+    description: string;
+    kind: 'range';
+    entity: string;
+    field: string;
+    min?: number;
+    max?: number;
+} | {
+    id: string;
+    description: string;
+    kind: 'count-equal';
+    sourceEntity: string;
+    targetEntity: string;
+} | {
+    id: string;
+    description: string;
+    kind: 'field-equal';
+    sourceEntity: string;
+    sourceField: string;
+    targetEntity: string;
+    targetField: string;
+} | {
+    id: string;
+    description: string;
+    kind: 'no-orphan';
+    entity: string;
+    field: string;
+    refEntity: string;
+} | {
+    id: string;
+    description: string;
+    kind: 'idempotent-copy';
+    sourceEntity: string;
+    targetEntity: string;
+} | {
+    id: string;
+    description: string;
+    kind: 'idempotent-migration';
+    from: string;
+    to: string;
+} | {
+    id: string;
+    description: string;
+    kind: 'monotonic';
+    entity: string;
+    field: string;
+    direction: 'inc' | 'dec';
+} | {
+    id: string;
+    description: string;
+    kind: 'sequence';
+    steps: string[];
+} | {
+    id: string;
+    description: string;
+    kind: 'leads-to';
+    entity: string;
+    field: string;
+    from: DataValue;
+    to: DataValue;
+} | {
+    id: string;
+    description: string;
+    kind: 'atomicity';
+    steps: string[];
+};
+export interface DataModelV1 {
+    schemaVersion: 1;
+    entities: EntitySpec[];
+    relationships?: RelationshipSpec[];
+    invariants?: DataInvariantSpec[];
+    boundaryChecks?: Array<{
+        entity: string;
+        field: string;
+        values?: DataValue[];
+    }>;
+}
+export interface CopyPairSpec {
+    id: string;
+    sourceEntity: string;
+    targetEntity: string;
+    mapping: Record<string, string>;
+}
+export interface BackupPairSpec {
+    id: string;
+    sourceEntity: string;
+    targetEntity: string;
+    mapping: Record<string, string>;
+}
+export interface MigrationMappingSpec {
+    id?: string;
+    from: string;
+    to: string;
+    transform?: 'copy' | 'rename' | 'split' | 'merge' | 'drop' | 'manual';
+    note?: string;
+}
+export interface DataVerificationOptions {
+    beforeModel?: unknown;
+    fieldMapping?: Record<string, string>;
+    copyPairs?: CopyPairSpec[];
+    migrationMappings?: MigrationMappingSpec[];
+    backupPairs?: BackupPairSpec[];
+}
+export interface DataComparisonSummary {
+    beforeModelHash: string;
+    afterModelHash: string;
+    fieldMapping: Record<string, string>;
+    beforeEntities: number;
+    beforeFields: number;
+    afterEntities: number;
+    afterFields: number;
+    addedEntities: string[];
+    removedEntities: string[];
+    addedFields: string[];
+    removedFields: string[];
+    addedRelationships: string[];
+    removedRelationships: string[];
+}
+export interface DataVerificationReport {
+    ok: boolean;
+    schemaVersion: 1;
+    modelHash: string;
+    summary: {
+        entities: number;
+        fields: number;
+        errors: number;
+        warnings: number;
+        checksRun: number;
+        truncated?: boolean;
+    };
+    checks: CheckResult[];
+    comparison?: DataComparisonSummary;
+}
+export declare function dataModelHash(model: DataModelV1): string;
+export declare function validateDataModel(input: unknown): {
+    ok: true;
+    model: DataModelV1;
+} | {
+    ok: false;
+    errors: string[];
+};
+export declare function runDataVerification(input: unknown, options?: DataVerificationOptions): DataVerificationReport;

package/lib/types/data-tool.d.ts

@@ -0,0 +1,10 @@
+import { DATA_ENGINE_SCHEMA_VERSION } from './data-engine.js';
+export declare const LOGICPROBE_DATAMODEL_VERIFY_TOOL_NAME = "logicprobe_datamodel_verify";
+/**
+ * Model-visible DSH tool wrapping the bundled data-model verification engine.
+ * The model passes a DataModelV1 object; the engine validates it and returns
+ * DS/DA/DD checks. Optional beforeModel/fieldMapping/copyPairs/migrationMappings
+ * enable before/after data-model regression and migration coverage checks.
+ */
+export declare const logicProbeDataModelVerifyTool: import("@deepseek-ai/dsh-tools").ToolDefinition;
+export { DATA_ENGINE_SCHEMA_VERSION };

package/lib/types/engine.d.ts

@@ -1,151 +1,171 @@
-export declare const ENGINE_SCHEMA_VERSION = 1;
-export type VarValue = number | boolean;
-export type GuardOp = '==' | '!=' | '<' | '<=' | '>' | '>=';
-export interface LeafGuard {
-    variable: string;
-    op: GuardOp;
-    value: VarValue;
-}
-export interface AllGuard {
-    all: GuardNode[];
-}
-export interface AnyGuard {
-    any: GuardNode[];
-}
-export interface NotGuard {
-    not: GuardNode;
-}
-export type GuardNode = LeafGuard | AllGuard | AnyGuard | NotGuard;
-export interface StateSpec {
-    id: string;
-    terminal?: boolean;
-}
-export interface UpdateSpec {
-    variable: string;
-    op: 'set' | 'inc' | 'dec';
-    value?: number;
-}
-export interface TransitionSpec {
-    from: string;
-    event: string;
-    to: string;
-    /** Absent guard is the else/default branch for the same (from, event) group. */
-    guard?: GuardNode;
-    updates?: UpdateSpec[];
-}
-export interface VariableSpec {
-    name: string;
-    kind: 'integer' | 'boolean';
-    init: number | boolean;
-    min?: number;
-    max?: number;
-}
-export type InvariantSpec = {
-    id: string;
-    description: string;
-    kind: 'never-states';
-    states: string[];
-} | {
-    id: string;
-    description: string;
-    kind: 'var-in-range';
-    variable: string;
-    min?: number;
-    max?: number;
-} | {
-    id: string;
-    description: string;
-    kind: 'event-before-state';
-    event: string;
-    state: string;
-};
-export interface ResourcePairSpec {
-    resource: string;
-    acquireEvent: string;
-    releaseEvent: string;
-    failEvent?: string;
-}
-export interface BoundaryCheckSpec {
-    variable: string;
-    values: number[];
-}
-export interface LogicModelV1 {
-    schemaVersion: 1;
-    init: string;
-    states: StateSpec[];
-    transitions: TransitionSpec[];
-    variables?: VariableSpec[];
-    invariants?: InvariantSpec[];
-    concurrentPairs?: [string, string][];
-    boundaryChecks?: BoundaryCheckSpec[];
-    resourcePairs?: ResourcePairSpec[];
-}
-export interface VerificationOptions {
-    maxStates?: number;
-    maxPermutationEvents?: number;
-    beforeModel?: unknown;
-    stateMapping?: Record<string, string>;
-}
-export interface PathStep {
-    from: string;
-    event: string;
-    to: string;
-}
-export interface Finding {
-    code: string;
-    severity: 'error' | 'warning';
-    message: string;
-    path?: PathStep[];
-    evidence?: Record<string, unknown>;
-}
-export interface CheckResult {
-    id: string;
-    name: string;
-    status: 'pass' | 'fail' | 'skip';
-    detail: string;
-    findings: Finding[];
-}
-export interface VerificationReport {
-    ok: boolean;
-    schemaVersion: 1;
-    modelHash: string;
-    summary: {
-        states: number;
-        transitions: number;
-        errors: number;
-        warnings: number;
-        checksRun: number;
-        truncated?: boolean;
-    };
-    checks: CheckResult[];
-    comparison?: ComparisonSummary;
-}
-export interface ComparisonSummary {
-    beforeModelHash: string;
-    afterModelHash: string;
-    stateMapping: Record<string, string>;
-    beforeStates: number;
-    beforeTransitions: number;
-    afterStates: number;
-    afterTransitions: number;
-    addedStates: string[];
-    removedStates: string[];
-    addedEvents: string[];
-    removedEvents: string[];
-    addedTransitions: TransitionSpec[];
-    removedTransitions: TransitionSpec[];
-}
-export interface RuntimeState {
-    state: string;
-    vars: Record<string, VarValue>;
-}
-export declare function modelHash(model: LogicModelV1): string;
-export declare function validateModel(input: unknown): {
-    ok: true;
-    model: LogicModelV1;
-} | {
-    ok: false;
-    errors: string[];
-};
-export declare function guardVariables(guard: GuardNode | undefined): string[];
-export declare function runVerification(input: unknown, options?: VerificationOptions): VerificationReport;
+export declare const ENGINE_SCHEMA_VERSION = 1;
+export type VarValue = number | boolean;
+export type GuardOp = '==' | '!=' | '<' | '<=' | '>' | '>=';
+export interface LeafGuard {
+    variable: string;
+    op: GuardOp;
+    value: VarValue;
+}
+export interface AllGuard {
+    all: GuardNode[];
+}
+export interface AnyGuard {
+    any: GuardNode[];
+}
+export interface NotGuard {
+    not: GuardNode;
+}
+export type GuardNode = LeafGuard | AllGuard | AnyGuard | NotGuard;
+export interface StateSpec {
+    id: string;
+    terminal?: boolean;
+}
+export interface UpdateSpec {
+    variable: string;
+    op: 'set' | 'inc' | 'dec';
+    value?: number;
+}
+export interface TransitionSpec {
+    from: string;
+    event: string;
+    to: string;
+    /** Absent guard is the else/default branch for the same (from, event) group. */
+    guard?: GuardNode;
+    updates?: UpdateSpec[];
+}
+export interface VariableSpec {
+    name: string;
+    kind: 'integer' | 'boolean';
+    init: number | boolean;
+    min?: number;
+    max?: number;
+    monotonic?: 'inc' | 'dec';
+}
+export type InvariantSpec = {
+    id: string;
+    description: string;
+    kind: 'never-states';
+    states: string[];
+} | {
+    id: string;
+    description: string;
+    kind: 'var-in-range';
+    variable: string;
+    min?: number;
+    max?: number;
+} | {
+    id: string;
+    description: string;
+    kind: 'event-before-state';
+    event: string;
+    state: string;
+} | {
+    id: string;
+    description: string;
+    kind: 'leads-to';
+    from: string;
+    to: string;
+} | {
+    id: string;
+    description: string;
+    kind: 'sequence';
+    events: string[];
+} | {
+    id: string;
+    description: string;
+    kind: 'atomicity';
+    events: string[];
+    commit: string;
+    rollback?: string;
+};
+export interface ResourcePairSpec {
+    resource: string;
+    acquireEvent: string;
+    releaseEvent: string;
+    failEvent?: string;
+}
+export interface BoundaryCheckSpec {
+    variable: string;
+    values: number[];
+}
+export interface LogicModelV1 {
+    schemaVersion: 1;
+    init: string;
+    states: StateSpec[];
+    transitions: TransitionSpec[];
+    variables?: VariableSpec[];
+    invariants?: InvariantSpec[];
+    concurrentPairs?: [string, string][];
+    boundaryChecks?: BoundaryCheckSpec[];
+    resourcePairs?: ResourcePairSpec[];
+    idempotentEvents?: string[];
+}
+export interface VerificationOptions {
+    maxStates?: number;
+    maxPermutationEvents?: number;
+    beforeModel?: unknown;
+    stateMapping?: Record<string, string>;
+}
+export interface PathStep {
+    from: string;
+    event: string;
+    to: string;
+}
+export interface Finding {
+    code: string;
+    severity: 'error' | 'warning';
+    message: string;
+    path?: PathStep[];
+    evidence?: Record<string, unknown>;
+}
+export interface CheckResult {
+    id: string;
+    name: string;
+    status: 'pass' | 'fail' | 'skip';
+    detail: string;
+    findings: Finding[];
+}
+export interface VerificationReport {
+    ok: boolean;
+    schemaVersion: 1;
+    modelHash: string;
+    summary: {
+        states: number;
+        transitions: number;
+        errors: number;
+        warnings: number;
+        checksRun: number;
+        truncated?: boolean;
+    };
+    checks: CheckResult[];
+    comparison?: ComparisonSummary;
+}
+export interface ComparisonSummary {
+    beforeModelHash: string;
+    afterModelHash: string;
+    stateMapping: Record<string, string>;
+    beforeStates: number;
+    beforeTransitions: number;
+    afterStates: number;
+    afterTransitions: number;
+    addedStates: string[];
+    removedStates: string[];
+    addedEvents: string[];
+    removedEvents: string[];
+    addedTransitions: TransitionSpec[];
+    removedTransitions: TransitionSpec[];
+}
+export interface RuntimeState {
+    state: string;
+    vars: Record<string, VarValue>;
+}
+export declare function modelHash(model: LogicModelV1): string;
+export declare function validateModel(input: unknown): {
+    ok: true;
+    model: LogicModelV1;
+} | {
+    ok: false;
+    errors: string[];
+};
+export declare function guardVariables(guard: GuardNode | undefined): string[];
+export declare function runVerification(input: unknown, options?: VerificationOptions): VerificationReport;