@wowok/agent-mcp 2.4.1 → 2.5.0

package/dist/knowledge/examples-scanner-cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/knowledge/examples-scanner-cli.js

@@ -0,0 +1,26 @@
+import { scanAllExamples, formatScanReport, EXAMPLES_SCANNER_VERSION } from './examples-scanner.js';
+import * as fs from 'fs';
+import * as path from 'path';
+console.log(`Examples Scanner v${EXAMPLES_SCANNER_VERSION}`);
+console.log('Scanning d:/wowok/docs/examples ...');
+const result = scanAllExamples();
+console.log(`Loaded ${result.examples.length} examples, found ${result.total_findings} findings.`);
+const report = formatScanReport(result);
+const outputPath = path.resolve('d:/wowok/wiki/market/GLM3/examples-scan-report.md');
+fs.writeFileSync(outputPath, report, 'utf-8');
+console.log(`Report written to ${outputPath}`);
+console.log('\n=== Per-Example Summary ===');
+for (const example of result.examples) {
+    const findings = result.findings_by_example.get(example.relative_path) ?? [];
+    const critical = findings.filter((f) => f.severity === "critical").length;
+    const high = findings.filter((f) => f.severity === "high").length;
+    const medium = findings.filter((f) => f.severity === "medium").length;
+    console.log(`${example.relative_path.padEnd(50)} machines=${example.machine_ops.length} ` +
+        `progress=${example.progress_ops.length} guards=${example.defined_guard_names.size} ` +
+        `findings=${findings.length} (C:${critical} H:${high} M:${medium})`);
+}
+console.log('\n=== Risk Rule Coverage ===');
+const sortedRules = [...result.risk_rule_coverage.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+for (const [ruleId, count] of sortedRules) {
+    console.log(`  ${ruleId.padEnd(15)} ${count}`);
+}

package/dist/knowledge/examples-scanner.d.ts

@@ -0,0 +1,121 @@
+import { type MachineNode, type MachinePair } from "./machine-topology.js";
+import { type CrossMachineDependency, type GuardResolution } from "./machine-context.js";
+export interface RawNodeDef {
+    name: string;
+    pairs: Array<{
+        prev_node: string;
+        threshold: number;
+        forwards: Array<{
+            name: string;
+            weight: number;
+            namedOperator?: string;
+            permissionIndex?: number;
+            named_operator?: string;
+            permission_index?: number;
+            guard?: unknown;
+            retained_submission?: unknown;
+        }>;
+    }>;
+}
+export interface RawMachineOp {
+    operation_type: "machine";
+    data: {
+        object: string | {
+            name: string;
+            permission?: string;
+            replaceExistName?: boolean;
+            replace_exist_name?: boolean;
+        };
+        description?: string;
+        node?: {
+            op: "add" | "replace" | "delete";
+            bReplace?: boolean;
+            nodes: RawNodeDef[];
+        };
+        publish?: boolean;
+    };
+    env: {
+        account?: string;
+        network?: "localnet" | "testnet" | "mainnet";
+        confirmed?: boolean;
+        no_cache?: boolean;
+    };
+}
+export declare function getMachineName(op: RawMachineOp): string;
+export interface RawProgressOp {
+    operation_type: string;
+    data: {
+        object: string;
+        progress?: {
+            operation: {
+                next_node_name: string;
+                forward: string;
+            };
+        };
+        submission?: unknown;
+    };
+    env: {
+        account?: string;
+        network?: "localnet" | "testnet" | "mainnet";
+    };
+    _source_line?: number;
+}
+export interface LoadedExample {
+    example_name: string;
+    relative_path: string;
+    absolute_path: string;
+    machine_ops: Array<{
+        op: RawMachineOp;
+        line_start: number;
+    }>;
+    progress_ops: RawProgressOp[];
+    defined_guard_names: Set<string>;
+    business_description?: string;
+}
+export type FindingSeverity = "critical" | "high" | "medium" | "low" | "info";
+export type FindingCategory = "schema_consistency" | "design" | "runtime" | "cross_machine" | "round_trip" | "progress" | "risk_rule";
+export interface Finding {
+    example: string;
+    source_file: string;
+    line: number;
+    machine_name: string;
+    category: FindingCategory;
+    severity: FindingSeverity;
+    title: string;
+    detail: string;
+    rule_id?: string;
+    fix?: string;
+}
+export declare function nodeDefsToMachine(nodeDefs: RawNodeDef[]): {
+    nodes: MachineNode[];
+    pairs: MachinePair[];
+};
+export declare function loadAllExamples(examplesDir?: string): LoadedExample[];
+export declare function analyzeSchemaConsistency(_example: LoadedExample): Finding[];
+export declare function analyzeThresholdIssues(example: LoadedExample): Finding[];
+export declare function analyzeNetworkSafety(example: LoadedExample): Finding[];
+export declare function analyzeConfirmationBypass(example: LoadedExample): Finding[];
+export declare function analyzeGuardReferences(example: LoadedExample): Finding[];
+export declare function analyzeCrossMachineDeps(example: LoadedExample, guardResolutions?: Map<string, GuardResolution>): {
+    deps: CrossMachineDependency[];
+    cycles: string[][];
+    findings: Finding[];
+};
+export declare function analyzeRoundTrip(example: LoadedExample): Finding[];
+export declare function analyzeProgressOps(example: LoadedExample): Finding[];
+export declare function analyzePublishStep(example: LoadedExample): Finding[];
+export declare function analyzeRiskRuleCoverage(example: LoadedExample): {
+    ruleCounts: Map<string, number>;
+    totalFindings: number;
+};
+export interface ScanResult {
+    examples: LoadedExample[];
+    findings_by_example: Map<string, Finding[]>;
+    findings_by_category: Map<FindingCategory, Finding[]>;
+    findings_by_severity: Map<FindingSeverity, Finding[]>;
+    total_findings: number;
+    risk_rule_coverage: Map<string, number>;
+}
+export declare function scanAllExamples(examplesDir?: string): ScanResult;
+export declare function formatScanReport(result: ScanResult): string;
+export declare const EXAMPLES_SCANNER_VERSION = "1.0.0";