@wowok/agent-mcp 2.7.1 → 2.7.3

package/dist/extensions/types.js

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

package/dist/graph/base.d.ts

@@ -0,0 +1,8 @@
+export interface GraphNodeBase {
+    id: string;
+    address?: string;
+}
+export interface GraphEdgeBase {
+    from: string;
+    to: string;
+}

package/dist/graph/base.js

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

package/dist/harness/auto-escalation.js

@@ -1,68 +1 @@
-import { getHarnessTier, setHarnessTier } from "../config/runtime.js";
-const state = {
-    current_tier: "lightweight",
-    history: [],
-    recent_failures: [],
-};
-const REPEATED_FAILURE_WINDOW_MS = 60_000;
-const REPEATED_FAILURE_THRESHOLD = 3;
-export function isFullTier(tier) {
-    return tier === "full";
-}
-export function shouldRunHeavyHooks() {
-    return isFullTier(getHarnessTier());
-}
-export function shouldRunLightHooks() {
-    const tier = getHarnessTier();
-    return tier === "lightweight" || tier === "full";
-}
-export function recordCriticalRisk(description) {
-    return escalate("E1_CRITICAL_RISK", `CRITICAL risk detected: ${description}`);
-}
-export function recordCriticalOperation(operation, errorCode) {
-    return escalate("E2_OPERATION_CRITICAL", `Operation '${operation}' returned CRITICAL error: ${errorCode}`);
-}
-export function recordSubstepFailure(detail) {
-    return escalate("E3_SUBSTEP_FAILURE", `Substep trace reported failure: ${detail}`);
-}
-export function recordOperationFailure(operation, errorCode) {
-    const now = Date.now();
-    state.recent_failures.push({ timestamp: now, operation, error_code: errorCode });
-    state.recent_failures = state.recent_failures.filter((f) => now - f.timestamp <= REPEATED_FAILURE_WINDOW_MS);
-    if (state.recent_failures.length >= REPEATED_FAILURE_THRESHOLD) {
-        const summary = state.recent_failures
-            .map((f) => `${f.operation}:${f.error_code}`)
-            .join(", ");
-        return escalate("E4_REPEATED_FAILURE", `Repeated failures (${state.recent_failures.length} in ${REPEATED_FAILURE_WINDOW_MS / 1000}s): ${summary}`);
-    }
-    return null;
-}
-export function getEscalationState() {
-    return {
-        current_tier: getHarnessTier(),
-        history: [...state.history],
-        recent_failures: [...state.recent_failures],
-    };
-}
-export function resetEscalation() {
-    state.history = [];
-    state.recent_failures = [];
-    setHarnessTier("lightweight");
-    state.current_tier = "lightweight";
-}
-function escalate(trigger, reason) {
-    const fromTier = getHarnessTier();
-    if (fromTier !== "lightweight")
-        return null;
-    const event = {
-        trigger,
-        timestamp: new Date().toISOString(),
-        reason,
-        from_tier: fromTier,
-        to_tier: "full",
-    };
-    setHarnessTier("full");
-    state.current_tier = "full";
-    state.history.push(event);
-    return event;
-}
+import{getHarnessTier,setHarnessTier}from'../config/runtime.js';const state={'current_tier':'lightweight','history':[],'recent_failures':[]},REPEATED_FAILURE_WINDOW_MS=0xea60,REPEATED_FAILURE_THRESHOLD=0x3;export function isFullTier(a){return a==='full';}export function shouldRunHeavyHooks(){return isFullTier(getHarnessTier());}export function shouldRunLightHooks(){const a=getHarnessTier();return a==='lightweight'||a==='full';}export function recordCriticalRisk(a){return escalate('E1_CRITICAL_RISK','CRITICAL\x20risk\x20detected:\x20'+a);}export function recordCriticalOperation(a,b){return escalate('E2_OPERATION_CRITICAL','Operation\x20\x27'+a+'\x27\x20returned\x20CRITICAL\x20error:\x20'+b);}export function recordSubstepFailure(a){return escalate('E3_SUBSTEP_FAILURE','Substep\x20trace\x20reported\x20failure:\x20'+a);}export function recordOperationFailure(a,b){const c=Date['now']();state['recent_failures']['push']({'timestamp':c,'operation':a,'error_code':b}),state['recent_failures']=state['recent_failures']['filter'](d=>c-d['timestamp']<=REPEATED_FAILURE_WINDOW_MS);if(state['recent_failures']['length']>=REPEATED_FAILURE_THRESHOLD){const d=state['recent_failures']['map'](e=>e['operation']+':'+e['error_code'])['join'](',\x20');return escalate('E4_REPEATED_FAILURE','Repeated\x20failures\x20('+state['recent_failures']['length']+'\x20in\x20'+REPEATED_FAILURE_WINDOW_MS/0x3e8+'s):\x20'+d);}return null;}export function getEscalationState(){return{'current_tier':getHarnessTier(),'history':[...state['history']],'recent_failures':[...state['recent_failures']]};}export function resetEscalation(){state['history']=[],state['recent_failures']=[],setHarnessTier('lightweight'),state['current_tier']='lightweight';}function escalate(a,b){const c=getHarnessTier();if(c!=='lightweight')return null;const d={'trigger':a,'timestamp':new Date()['toISOString'](),'reason':b,'from_tier':c,'to_tier':'full'};return setHarnessTier('full'),state['current_tier']='full',state['history']['push'](d),d;}

package/dist/harness/checkpoint.js

@@ -1,129 +1 @@
-import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, unlinkSync, openSync, closeSync } from "fs";
-import { join } from "path";
-import { getWowMcpDir } from "@wowok/wowok";
-const CHECKPOINT_ROOT = join(getWowMcpDir(), "checkpoints");
-function getTaskDir(taskId) {
-    return join(CHECKPOINT_ROOT, taskId);
-}
-function getCheckpointPath(taskId, checkpointId) {
-    return join(getTaskDir(taskId), `${checkpointId}.json`);
-}
-function getLatestPath(taskId) {
-    return join(getTaskDir(taskId), "latest.json");
-}
-function acquireLock(filePath) {
-    const lockPath = filePath + ".lock";
-    try {
-        const fd = openSync(lockPath, "wx");
-        closeSync(fd);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function releaseLock(filePath) {
-    const lockPath = filePath + ".lock";
-    try {
-        unlinkSync(lockPath);
-    }
-    catch {
-    }
-}
-export function saveCheckpoint(cp) {
-    const taskDir = getTaskDir(cp.task_id);
-    if (!existsSync(taskDir)) {
-        mkdirSync(taskDir, { recursive: true });
-    }
-    const cpPath = getCheckpointPath(cp.task_id, cp.checkpoint_id);
-    const latestPath = getLatestPath(cp.task_id);
-    if (!acquireLock(cpPath)) {
-        throw new Error(`Cannot acquire lock for checkpoint ${cp.checkpoint_id} — another process may be writing`);
-    }
-    try {
-        writeFileSync(cpPath, JSON.stringify(cp, null, 2), "utf8");
-        writeFileSync(latestPath, JSON.stringify(cp, null, 2), "utf8");
-    }
-    finally {
-        releaseLock(cpPath);
-    }
-}
-export function loadCheckpoint(taskId, checkpointId) {
-    const cpPath = getCheckpointPath(taskId, checkpointId);
-    if (!existsSync(cpPath))
-        return null;
-    try {
-        const raw = readFileSync(cpPath, "utf8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-export function loadLatestCheckpoint(taskId) {
-    const latestPath = getLatestPath(taskId);
-    if (!existsSync(latestPath))
-        return null;
-    try {
-        const raw = readFileSync(latestPath, "utf8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-export function listCheckpoints(taskId) {
-    const taskDir = getTaskDir(taskId);
-    if (!existsSync(taskDir))
-        return [];
-    const files = readdirSync(taskDir)
-        .filter((f) => f.endsWith(".json") && f !== "latest.json")
-        .sort();
-    return files
-        .map((f) => {
-        try {
-            const raw = readFileSync(join(taskDir, f), "utf8");
-            return JSON.parse(raw);
-        }
-        catch {
-            return null;
-        }
-    })
-        .filter((cp) => cp !== null);
-}
-export function listTasks() {
-    if (!existsSync(CHECKPOINT_ROOT))
-        return [];
-    return readdirSync(CHECKPOINT_ROOT, { withFileTypes: true })
-        .filter((d) => d.isDirectory())
-        .map((d) => d.name);
-}
-export function deleteCheckpoint(taskId, checkpointId) {
-    const cpPath = getCheckpointPath(taskId, checkpointId);
-    if (existsSync(cpPath)) {
-        if (!acquireLock(cpPath)) {
-            throw new Error(`Cannot acquire lock for deletion of ${checkpointId}`);
-        }
-        try {
-            unlinkSync(cpPath);
-        }
-        finally {
-            releaseLock(cpPath);
-        }
-    }
-}
-export function createCheckpoint(taskId, phase, phaseStatus, odgSnapshot, userDecisions, operationLog, nextPhase, semanticSummary) {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    return {
-        checkpoint_id: `CP-${phase.replace(/\s+/g, "")}-${phaseStatus}-${timestamp}`,
-        task_id: taskId,
-        timestamp: new Date().toISOString(),
-        phase,
-        phase_status: phaseStatus,
-        odg_snapshot: odgSnapshot,
-        user_decisions: userDecisions,
-        operation_log: operationLog,
-        next_phase: nextPhase,
-        semantic_summary: semanticSummary,
-    };
-}
+import{existsSync,mkdirSync,writeFileSync,readFileSync,readdirSync,unlinkSync,openSync,closeSync}from'fs';import{join}from'path';import{getWowMcpDir}from'@wowok/wowok';const CHECKPOINT_ROOT=join(getWowMcpDir(),'checkpoints');function getTaskDir(a){return join(CHECKPOINT_ROOT,a);}function getCheckpointPath(a,b){return join(getTaskDir(a),b+'.json');}function getLatestPath(a){return join(getTaskDir(a),'latest.json');}function acquireLock(a){const b=a+'.lock';try{const c=openSync(b,'wx');return closeSync(c),!![];}catch{return![];}}function releaseLock(a){const b=a+'.lock';try{unlinkSync(b);}catch{}}export function saveCheckpoint(a){const b=getTaskDir(a['task_id']);!existsSync(b)&&mkdirSync(b,{'recursive':!![]});const c=getCheckpointPath(a['task_id'],a['checkpoint_id']),d=getLatestPath(a['task_id']);if(!acquireLock(c))throw new Error('Cannot\x20acquire\x20lock\x20for\x20checkpoint\x20'+a['checkpoint_id']+'\x20—\x20another\x20process\x20may\x20be\x20writing');try{writeFileSync(c,JSON['stringify'](a,null,0x2),'utf8'),writeFileSync(d,JSON['stringify'](a,null,0x2),'utf8');}finally{releaseLock(c);}}export function loadCheckpoint(a,b){const c=getCheckpointPath(a,b);if(!existsSync(c))return null;try{const d=readFileSync(c,'utf8');return JSON['parse'](d);}catch{return null;}}export function loadLatestCheckpoint(a){const b=getLatestPath(a);if(!existsSync(b))return null;try{const c=readFileSync(b,'utf8');return JSON['parse'](c);}catch{return null;}}export function listCheckpoints(a){const b=getTaskDir(a);if(!existsSync(b))return[];const c=readdirSync(b)['filter'](d=>d['endsWith']('.json')&&d!=='latest.json')['sort']();return c['map'](d=>{try{const e=readFileSync(join(b,d),'utf8');return JSON['parse'](e);}catch{return null;}})['filter'](d=>d!==null);}export function listTasks(){if(!existsSync(CHECKPOINT_ROOT))return[];return readdirSync(CHECKPOINT_ROOT,{'withFileTypes':!![]})['filter'](a=>a['isDirectory']())['map'](a=>a['name']);}export function deleteCheckpoint(a,b){const c=getCheckpointPath(a,b);if(existsSync(c)){if(!acquireLock(c))throw new Error('Cannot\x20acquire\x20lock\x20for\x20deletion\x20of\x20'+b);try{unlinkSync(c);}finally{releaseLock(c);}}}export function createCheckpoint(a,b,c,d,e,f,g,h){const i=new Date()['toISOString']()['replace'](/[:.]/g,'-');return{'checkpoint_id':'CP-'+b['replace'](/\s+/g,'')+'-'+c+'-'+i,'task_id':a,'timestamp':new Date()['toISOString'](),'phase':b,'phase_status':c,'odg_snapshot':d,'user_decisions':e,'operation_log':f,'next_phase':g,'semantic_summary':h};}

package/dist/harness/index.d.ts

@@ -9,6 +9,7 @@ import type { ODG, ExpectedResult, VerifyReport, RecoveryAction, Checkpoint } fr
 export declare class Harness {
     private context;
     plan(userInput: string, taskId?: string): ODG;
+    planFromSemanticGraph(graph: import("../project/semantic-graph.js").SemanticObjectGraph, taskId?: string): ODG;
     classifyIntent(userInput: string): import("./plan.js").IntentClassification;
     getDecisions(odg: ODG): DecisionPoint[];
     getMigrationDecisions(options?: {

package/dist/harness/index.js

@@ -1,78 +1 @@
-export * from "./types.js";
-export * from "./plan.js";
-export * from "./verify.js";
-export * from "./recover.js";
-export * from "./checkpoint.js";
-import { classifyIntent, generateODG, identifyDecisionPoints, detectCycles, SCENARIO_REGISTRY, identifyMigrationDecisions } from "./plan.js";
-import { verify, generateExpected } from "./verify.js";
-import { recover, resetAttempts, getBackoffDelay, RECOVERY_RULES } from "./recover.js";
-import { saveCheckpoint, loadLatestCheckpoint, listCheckpoints, listTasks, createCheckpoint } from "./checkpoint.js";
-export class Harness {
-    context = new Map();
-    plan(userInput, taskId) {
-        return generateODG(userInput, taskId);
-    }
-    classifyIntent(userInput) {
-        return classifyIntent(userInput);
-    }
-    getDecisions(odg) {
-        return identifyDecisionPoints(odg);
-    }
-    getMigrationDecisions(options) {
-        return identifyMigrationDecisions(options);
-    }
-    detectCycles(odg) {
-        return detectCycles(odg);
-    }
-    getScenarioRegistry() {
-        return SCENARIO_REGISTRY;
-    }
-    expect(operation, intent, operationType, data) {
-        return generateExpected(operation, intent, operationType, data);
-    }
-    verify(input) {
-        return verify(input);
-    }
-    recover(errorCode, operationId, context) {
-        return recover(errorCode, operationId, context);
-    }
-    resetRecovery(operationId) {
-        resetAttempts(operationId);
-    }
-    getBackoffDelay(attempt) {
-        return getBackoffDelay(attempt);
-    }
-    getRecoveryRules() {
-        return RECOVERY_RULES;
-    }
-    checkpoint(taskId, phase, phaseStatus, odgSnapshot, userDecisions, operationLog, nextPhase, semanticSummary) {
-        const cp = createCheckpoint(taskId, phase, phaseStatus, odgSnapshot, userDecisions, operationLog, nextPhase, semanticSummary);
-        saveCheckpoint(cp);
-        return cp;
-    }
-    loadCheckpoint(taskId) {
-        return loadLatestCheckpoint(taskId);
-    }
-    listCheckpoints(taskId) {
-        return listCheckpoints(taskId);
-    }
-    listTasks() {
-        return listTasks();
-    }
-    setContext(key, value) {
-        this.context.set(key, value);
-    }
-    getContext(key) {
-        return this.context.get(key);
-    }
-}
-let singleton = null;
-export function getHarness() {
-    if (!singleton) {
-        singleton = new Harness();
-    }
-    return singleton;
-}
-export function setHarness(h) {
-    singleton = h;
-}
+export*from'./types.js';export*from'./plan.js';export*from'./verify.js';export*from'./recover.js';export*from'./checkpoint.js';import{classifyIntent,generateODG,generateODGFromSemanticGraph,identifyDecisionPoints,detectCycles,SCENARIO_REGISTRY,identifyMigrationDecisions}from'./plan.js';import{verify,generateExpected}from'./verify.js';import{recover,resetAttempts,getBackoffDelay,RECOVERY_RULES}from'./recover.js';import{saveCheckpoint,loadLatestCheckpoint,listCheckpoints,listTasks,createCheckpoint}from'./checkpoint.js';export class Harness{['context']=new Map();['plan'](a,b){return generateODG(a,b);}['planFromSemanticGraph'](a,b){return generateODGFromSemanticGraph(a,b);}['classifyIntent'](a){return classifyIntent(a);}['getDecisions'](a){return identifyDecisionPoints(a);}['getMigrationDecisions'](a){return identifyMigrationDecisions(a);}['detectCycles'](a){return detectCycles(a);}['getScenarioRegistry'](){return SCENARIO_REGISTRY;}['expect'](a,b,c,d){return generateExpected(a,b,c,d);}['verify'](a){return verify(a);}['recover'](a,b,c){return recover(a,b,c);}['resetRecovery'](a){resetAttempts(a);}['getBackoffDelay'](a){return getBackoffDelay(a);}['getRecoveryRules'](){return RECOVERY_RULES;}['checkpoint'](a,b,c,d,e,f,g,h){const i=createCheckpoint(a,b,c,d,e,f,g,h);return saveCheckpoint(i),i;}['loadCheckpoint'](a){return loadLatestCheckpoint(a);}['listCheckpoints'](a){return listCheckpoints(a);}['listTasks'](){return listTasks();}['setContext'](a,b){this['context']['set'](a,b);}['getContext'](a){return this['context']['get'](a);}}let singleton=null;export function getHarness(){return!singleton&&(singleton=new Harness()),singleton;}export function setHarness(a){singleton=a;}

package/dist/harness/plan.d.ts

@@ -1,4 +1,5 @@
 import type { ODG, ScenarioTemplate } from "./types.js";
+import type { SemanticObjectGraph } from "../project/semantic-graph.js";
 export declare const SCENARIO_REGISTRY: ScenarioTemplate[];
 export interface IntentClassification {
     scenario: string;
@@ -8,6 +9,7 @@ export interface IntentClassification {
 }
 export declare function classifyIntent(userInput: string): IntentClassification;
 export declare function generateODG(userInput: string, taskId?: string): ODG;
+export declare function generateODGFromSemanticGraph(graph: SemanticObjectGraph, taskId?: string): ODG;
 export interface DecisionPoint {
     round: string;
     question: string;