@wowok/agent-mcp 2.5.1 → 2.5.3

package/dist/project/project-store.js

@@ -0,0 +1,425 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, copyFileSync, statSync, appendFileSync, } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+export const CURRENT_SCHEMA_VERSION = "1.0.0";
+export function projectsRootDir() {
+    const base = process.env.WOWOK_CONFIG_DIR
+        ? process.env.WOWOK_CONFIG_DIR
+        : join(homedir(), ".wowok");
+    return join(base, "projects");
+}
+export function projectDir(prefix, version) {
+    return join(projectsRootDir(), `${prefix}_${version}`);
+}
+export function deploymentDir(prefix, version) {
+    return join(projectDir(prefix, version), "deployment");
+}
+function manifestPath(prefix, version) {
+    return join(projectDir(prefix, version), "manifest.json");
+}
+function stageStatePath(prefix, version) {
+    return join(projectDir(prefix, version), "stage.json");
+}
+function auditLogPath(prefix, version) {
+    return join(projectDir(prefix, version), "audit.jsonl");
+}
+export function ensureProjectDir(prefix, version) {
+    const dir = projectDir(prefix, version);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+export function initProject(prefix, version, options = {}) {
+    ensureProjectDir(prefix, version);
+    const now = new Date().toISOString();
+    const manifest = {
+        schema_version: CURRENT_SCHEMA_VERSION,
+        mcp_version: options.mcpVersion ?? "unknown",
+        prefix,
+        version,
+        created_at: now,
+        updated_at: now,
+        forked_from: options.forkedFrom,
+    };
+    writeFileSync(manifestPath(prefix, version), JSON.stringify(manifest, null, 2), "utf-8");
+    const stageState = {
+        stage: 1,
+        updated_at: Date.now(),
+        stage_meta: {
+            1: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            2: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            3: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            4: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            5: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+        },
+        has_published_object: false,
+        archived: false,
+    };
+    saveStageState(prefix, version, stageState);
+    appendAudit(prefix, version, {
+        timestamp: now,
+        event: "stage_commit",
+        stage: 1,
+        reason: `project initialized${options.forkedFrom ? ` (forked from ${options.forkedFrom})` : ""}`,
+        affected_files: ["manifest.json", "stage.json"],
+    });
+    return manifest;
+}
+export function loadManifest(prefix, version) {
+    const p = manifestPath(prefix, version);
+    if (!existsSync(p)) {
+        throw new Error(`project not initialized: ${prefix}_${version} (missing manifest.json)`);
+    }
+    const raw = readFileSync(p, "utf-8");
+    return JSON.parse(raw);
+}
+export function saveManifest(prefix, version, manifest) {
+    manifest.updated_at = new Date().toISOString();
+    writeFileSync(manifestPath(prefix, version), JSON.stringify(manifest, null, 2), "utf-8");
+}
+export function loadStageState(prefix, version) {
+    const p = stageStatePath(prefix, version);
+    if (!existsSync(p))
+        return undefined;
+    const raw = readFileSync(p, "utf-8");
+    return JSON.parse(raw);
+}
+export function saveStageState(prefix, version, state) {
+    state.updated_at = Date.now();
+    ensureProjectDir(prefix, version);
+    writeFileSync(stageStatePath(prefix, version), JSON.stringify(state, null, 2), "utf-8");
+}
+export function saveProjectFile(prefix, version, relPath, data) {
+    const abs = join(projectDir(prefix, version), relPath);
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, JSON.stringify(data, null, 2), "utf-8");
+    return abs;
+}
+export function loadProjectFile(prefix, version, relPath) {
+    const abs = join(projectDir(prefix, version), relPath);
+    if (!existsSync(abs))
+        return undefined;
+    const raw = readFileSync(abs, "utf-8");
+    return JSON.parse(raw);
+}
+export function saveProjectMarkdown(prefix, version, relPath, markdown) {
+    const abs = join(projectDir(prefix, version), relPath);
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, markdown, "utf-8");
+    return abs;
+}
+export function appendJsonl(prefix, version, relPath, record) {
+    const abs = join(projectDir(prefix, version), relPath);
+    ensureProjectDir(prefix, version);
+    mkdirSync(dirname(abs), { recursive: true });
+    appendFileSync(abs, JSON.stringify(record) + "\n", "utf-8");
+    return abs;
+}
+export function appendAudit(prefix, version, record) {
+    appendJsonl(prefix, version, "audit.jsonl", record);
+}
+export function readAuditLog(prefix, version) {
+    const abs = auditLogPath(prefix, version);
+    if (!existsSync(abs))
+        return [];
+    const raw = readFileSync(abs, "utf-8");
+    return raw
+        .split("\n")
+        .filter((l) => l.trim().length > 0)
+        .map((l) => JSON.parse(l));
+}
+export function parseProjectDirName(dirName) {
+    const m = dirName.match(/^(.+)_v(\d+)$/);
+    if (!m)
+        return undefined;
+    return { prefix: m[1], version: `v${m[2]}` };
+}
+export function listLocalProjects() {
+    const root = projectsRootDir();
+    if (!existsSync(root))
+        return [];
+    const entries = readdirSync(root, { withFileTypes: true });
+    const out = [];
+    for (const e of entries) {
+        if (!e.isDirectory())
+            continue;
+        const parsed = parseProjectDirName(e.name);
+        if (!parsed)
+            continue;
+        const fullPath = join(root, e.name);
+        const manifestFile = join(fullPath, "manifest.json");
+        const stageFile = join(fullPath, "stage.json");
+        let initialized = false;
+        let archived = false;
+        let needsMigration = false;
+        let forkedFrom;
+        if (existsSync(manifestFile)) {
+            initialized = true;
+            try {
+                const m = JSON.parse(readFileSync(manifestFile, "utf-8"));
+                needsMigration = m.schema_version !== CURRENT_SCHEMA_VERSION;
+                forkedFrom = m.forked_from;
+            }
+            catch {
+            }
+        }
+        if (existsSync(stageFile)) {
+            try {
+                const s = JSON.parse(readFileSync(stageFile, "utf-8"));
+                archived = s.archived;
+            }
+            catch {
+            }
+        }
+        let mtime = 0;
+        try {
+            mtime = statSync(fullPath).mtimeMs;
+        }
+        catch {
+        }
+        out.push({
+            dir_name: e.name,
+            prefix: parsed.prefix,
+            version: parsed.version,
+            path: fullPath,
+            initialized,
+            archived,
+            needs_migration: needsMigration,
+            forked_from: forkedFrom,
+            mtime,
+        });
+    }
+    return out.sort((a, b) => b.mtime - a.mtime);
+}
+export function projectExists(prefix, version) {
+    return existsSync(manifestPath(prefix, version));
+}
+export function forkProject(srcPrefix, srcVersion, opts) {
+    if (!projectExists(srcPrefix, srcVersion)) {
+        throw new Error(`source project not found: ${srcPrefix}_${srcVersion}`);
+    }
+    const newPrefix = opts.newPrefix ?? srcPrefix;
+    if (opts.newVersion === srcVersion && newPrefix === srcPrefix) {
+        throw new Error("fork target must differ from source (set newVersion or newPrefix)");
+    }
+    ensureProjectDir(newPrefix, opts.newVersion);
+    const srcDir = projectDir(srcPrefix, srcVersion);
+    const dstDir = projectDir(newPrefix, opts.newVersion);
+    const copiedFiles = [];
+    function walkDir(relBase) {
+        const absBase = join(srcDir, relBase);
+        if (!existsSync(absBase))
+            return;
+        const items = readdirSync(absBase, { withFileTypes: true });
+        for (const item of items) {
+            const rel = relBase ? join(relBase, item.name) : item.name;
+            const srcAbs = join(srcDir, rel);
+            const dstAbs = join(dstDir, rel);
+            if (item.isDirectory()) {
+                mkdirSync(dstAbs, { recursive: true });
+                walkDir(rel);
+            }
+            else if (item.isFile()) {
+                if (rel === "stage.json" || rel === "audit.jsonl")
+                    continue;
+                mkdirSync(dirname(dstAbs), { recursive: true });
+                copyFileSync(srcAbs, dstAbs);
+                copiedFiles.push(rel);
+            }
+        }
+    }
+    walkDir("");
+    const now = new Date().toISOString();
+    const manifest = {
+        schema_version: CURRENT_SCHEMA_VERSION,
+        mcp_version: opts.mcpVersion ?? "unknown",
+        prefix: newPrefix,
+        version: opts.newVersion,
+        created_at: now,
+        updated_at: now,
+        forked_from: srcDir,
+    };
+    writeFileSync(manifestPath(newPrefix, opts.newVersion), JSON.stringify(manifest, null, 2), "utf-8");
+    const stageState = {
+        stage: 1,
+        updated_at: Date.now(),
+        stage_meta: {
+            1: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            2: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            3: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            4: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            5: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+        },
+        has_published_object: false,
+        archived: false,
+    };
+    saveStageState(newPrefix, opts.newVersion, stageState);
+    appendAudit(newPrefix, opts.newVersion, {
+        timestamp: now,
+        event: "fork_created",
+        reason: `forked from ${srcPrefix}_${srcVersion}; objects must be re-created (project isolation §3.0)`,
+        affected_files: ["manifest.json", "stage.json"],
+    });
+    const srcStage = loadStageState(srcPrefix, srcVersion);
+    if (srcStage) {
+        srcStage.archived = true;
+        saveStageState(srcPrefix, srcVersion, srcStage);
+        appendAudit(srcPrefix, srcVersion, {
+            timestamp: now,
+            event: "stage_commit",
+            reason: `archived after fork to ${newPrefix}_${opts.newVersion}`,
+            affected_files: ["stage.json"],
+        });
+    }
+    return {
+        new_prefix: newPrefix,
+        new_version: opts.newVersion,
+        new_path: dstDir,
+        forked_from: srcDir,
+        copied_files: copiedFiles,
+    };
+}
+export function listProjectFiles(prefix, version) {
+    const dir = projectDir(prefix, version);
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    function walk(relBase) {
+        const absBase = join(dir, relBase);
+        const items = readdirSync(absBase, { withFileTypes: true });
+        for (const item of items) {
+            const rel = relBase ? join(relBase, item.name) : item.name;
+            const abs = join(dir, rel);
+            if (item.isDirectory()) {
+                walk(rel);
+            }
+            else if (item.isFile()) {
+                let stat;
+                try {
+                    stat = statSync(abs);
+                }
+                catch {
+                    continue;
+                }
+                let kind = "other";
+                if (abs.endsWith(".json"))
+                    kind = "json";
+                else if (abs.endsWith(".md"))
+                    kind = "markdown";
+                else if (abs.endsWith(".jsonl"))
+                    kind = "jsonl";
+                out.push({
+                    path: rel,
+                    abs_path: abs,
+                    size: stat.size,
+                    mtime: stat.mtimeMs,
+                    kind,
+                });
+            }
+        }
+    }
+    walk("");
+    return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+export function readProjectFile(prefix, version, relPath) {
+    const abs = join(projectDir(prefix, version), relPath);
+    if (!existsSync(abs))
+        return undefined;
+    return readFileSync(abs, "utf-8");
+}
+export function commitStage(prefix, version, stage, options = {}) {
+    const state = loadStageState(prefix, version);
+    if (!state) {
+        throw new Error(`project not initialized: ${prefix}_${version}`);
+    }
+    const gatePassed = options.gatePassed ?? false;
+    state.stage_meta[stage] = {
+        committed: true,
+        committed_at: Date.now(),
+        gate_passed: gatePassed,
+        blocking_issues: options.blockingIssues ?? [],
+        completion: options.completion ?? (gatePassed ? 100 : 0),
+    };
+    if (stage < 5 && gatePassed) {
+        state.stage = (stage + 1);
+    }
+    saveStageState(prefix, version, state);
+    appendAudit(prefix, version, {
+        timestamp: new Date().toISOString(),
+        event: "stage_commit",
+        stage,
+        reason: options.reason ?? `stage ${stage} committed`,
+        affected_files: ["stage.json"],
+        user_confirmed: options.userConfirmed,
+    });
+    return state;
+}
+export function rollbackStage(prefix, version, toStage, options = {}) {
+    const state = loadStageState(prefix, version);
+    if (!state) {
+        throw new Error(`project not initialized: ${prefix}_${version}`);
+    }
+    if (state.has_published_object) {
+        throw new Error(`cannot rollback: project has published objects — must fork new version (§3.3)`);
+    }
+    const oldStage = state.stage;
+    for (let s = toStage + 1; s <= 5; s++) {
+        state.stage_meta[s] = {
+            committed: false,
+            gate_passed: false,
+            blocking_issues: [],
+            completion: 0,
+        };
+    }
+    state.stage = toStage;
+    saveStageState(prefix, version, state);
+    appendAudit(prefix, version, {
+        timestamp: new Date().toISOString(),
+        event: "stage_rollback",
+        stage: toStage,
+        reason: options.reason ?? `rollback from stage ${oldStage} to ${toStage}`,
+        affected_files: options.affectedFiles ?? ["stage.json"],
+    });
+    return state;
+}
+export function markObjectPublished(prefix, version, objectName) {
+    const state = loadStageState(prefix, version);
+    if (!state)
+        return;
+    if (state.has_published_object)
+        return;
+    state.has_published_object = true;
+    saveStageState(prefix, version, state);
+    appendAudit(prefix, version, {
+        timestamp: new Date().toISOString(),
+        event: "object_published",
+        stage: 5,
+        reason: `object published: ${objectName} — rollback now requires fork (§3.3)`,
+        affected_files: ["stage.json"],
+    });
+}
+export function getLocalSyncStatus(prefix, version) {
+    const exists = projectExists(prefix, version);
+    if (!exists) {
+        return { local_exists: false, initialized: false, needs_migration: false, archived: false };
+    }
+    let initialized = true;
+    let needsMigration = false;
+    let archived = false;
+    try {
+        const m = loadManifest(prefix, version);
+        needsMigration = m.schema_version !== CURRENT_SCHEMA_VERSION;
+    }
+    catch {
+        initialized = false;
+    }
+    try {
+        const s = loadStageState(prefix, version);
+        if (s)
+            archived = s.archived;
+    }
+    catch {
+    }
+    return { local_exists: true, initialized, needs_migration: needsMigration, archived };
+}

package/dist/project/risk-aggregator.d.ts

@@ -40,6 +40,13 @@ export interface RiskAggregationResult {
         entry_id: string;
     }>;
     calibrated_at: number;
+    fix_suggestions_grouped?: Record<string, Array<{
+        risk_rule_id: string;
+        severity: RiskSeverity;
+        message: string;
+        fix_suggestion: string;
+        entry_id: string;
+    }>>;
     warnings: string[];
 }
 export declare function aggregateProjectRisks(input: RiskAggregationInput): RiskAggregationResult;

package/dist/project/risk-aggregator.js

@@ -179,6 +179,20 @@ export function aggregateProjectRisks(input) {
             entry_id: f.entry_id,
         }));
     }
+    const fixSuggestionsGrouped = {};
+    for (const finding of findings) {
+        const key = finding.object_type;
+        if (!fixSuggestionsGrouped[key]) {
+            fixSuggestionsGrouped[key] = [];
+        }
+        fixSuggestionsGrouped[key].push({
+            risk_rule_id: finding.risk_rule_id,
+            severity: finding.severity,
+            message: finding.message,
+            fix_suggestion: finding.fix_suggestion,
+            entry_id: finding.entry_id,
+        });
+    }
     return {
         namespace: {
             prefix: input.project_prefix ?? "",
@@ -190,6 +204,7 @@ export function aggregateProjectRisks(input) {
         status,
         pending_confirmations,
         calibrated_at: Date.now(),
+        fix_suggestions_grouped: fixSuggestionsGrouped,
         warnings,
     };
 }

package/dist/project/rollback-policy.d.ts

@@ -0,0 +1,45 @@
+import { type ProjectStage, type StageState } from "./project-store.js";
+export type ObjectLifecycleState = "created" | "referenced" | "published" | "bound";
+export type StructReversibility = "reversible" | "limited" | "immutable";
+export type GasImpact = "low" | "medium" | "high" | "none";
+export interface ReversibilityEntry {
+    object_type: string;
+    lifecycle_state: ObjectLifecycleState;
+    struct_reversible: StructReversibility;
+    behavior_reversible: boolean;
+    gas_impact: GasImpact;
+    explanation: string;
+}
+export declare const REVERSIBILITY_MATRIX: ReversibilityEntry[];
+export declare function queryReversibility(objectType: string, lifecycleState: ObjectLifecycleState): ReversibilityEntry | undefined;
+export declare function getReversibilityForType(objectType: string): ReversibilityEntry[];
+export type IterationStrategy = "in_place" | "fork";
+export interface IterationRecommendation {
+    strategy: IterationStrategy;
+    reason: string;
+    fork_to_version?: string;
+    published_objects?: string[];
+}
+export declare function recommendIterationStrategy(prefix: string, version: string, currentStage?: ProjectStage): IterationRecommendation;
+export interface RollbackPolicyResult {
+    allowed: boolean;
+    target_stage: ProjectStage;
+    current_stage: ProjectStage;
+    block_reason?: string;
+    files_to_clean: string[];
+    warnings: string[];
+    iteration_strategy: IterationRecommendation;
+}
+export declare function evaluateRollbackPolicy(prefix: string, version: string, targetStage: ProjectStage): RollbackPolicyResult;
+export interface RollbackResult {
+    success: boolean;
+    target_stage: ProjectStage;
+    previous_stage: ProjectStage;
+    files_to_clean: string[];
+    files_cleaned: string[];
+    stage_state: StageState;
+    warnings: string[];
+    iteration_strategy: IterationRecommendation;
+    message: string;
+}
+export declare function rollbackStageWithPolicy(prefix: string, version: string, targetStage: ProjectStage, reason?: string): RollbackResult;