@wowok/agent-mcp 2.5.1 → 2.5.3

package/dist/project/index.d.ts

@@ -7,6 +7,31 @@ export * from "./query.js";
 export declare function isProjectServiceEnabled(): boolean;
 export declare function getGraph(): ProjectGraph;
 export declare function setGraph(g: ProjectGraph): void;
+export type ProjectStage = 1 | 2 | 3 | 4 | 5;
+export interface StageCacheEntry {
+    stage: ProjectStage;
+    updated_at: number;
+    puzzles?: Record<string, unknown>;
+    risk_status?: string;
+    risk_can_proceed?: boolean;
+    doc_generated?: boolean;
+    doc_error_count?: number;
+    trace_coherent?: boolean;
+    trace_can_proceed?: boolean;
+    business_intent?: string;
+    industry?: string;
+}
+export declare function getStageCache(prefix: string, version: string): StageCacheEntry | undefined;
+export declare function updateStageCache(prefix: string, version: string, update: Partial<StageCacheEntry>): StageCacheEntry;
+export declare function getProjectStatus(prefix: string, version: string): {
+    stage: ProjectStage;
+    stage_name: string;
+    stage_description: string;
+    next_action: string;
+    can_proceed: boolean;
+    details: StageCacheEntry | undefined;
+};
+export declare function clearStageCache(prefix: string, version: string): void;
 export interface NormalizeCallInput {
     operation_type: string;
     data: any;

package/dist/project/index.js

@@ -6,6 +6,7 @@ import { LocalMark } from "@wowok/wowok";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { dirname, join } from "path";
 import { homedir } from "os";
+import * as ProjectStore from "./project-store.js";
 export * from "./namespace.js";
 export * from "./graph.js";
 export * from "./query.js";
@@ -62,6 +63,83 @@ export function getGraph() {
 export function setGraph(g) {
     GRAPH_INSTANCE = g;
 }
+const STAGE_CACHE = new Map();
+function stageCacheKey(prefix, version) {
+    return `${prefix}:${version}`;
+}
+export function getStageCache(prefix, version) {
+    const key = stageCacheKey(prefix, version);
+    const cached = STAGE_CACHE.get(key);
+    if (cached)
+        return cached;
+    const stageState = ProjectStore.loadStageState(prefix, version);
+    if (stageState) {
+        const entry = {
+            stage: stageState.stage,
+            updated_at: stageState.updated_at,
+        };
+        STAGE_CACHE.set(key, entry);
+        return entry;
+    }
+    return undefined;
+}
+export function updateStageCache(prefix, version, update) {
+    const key = stageCacheKey(prefix, version);
+    const existing = STAGE_CACHE.get(key);
+    const entry = {
+        stage: update.stage ?? existing?.stage ?? 1,
+        updated_at: Date.now(),
+        ...existing,
+        ...update,
+    };
+    STAGE_CACHE.set(key, entry);
+    persistStageState(prefix, version, entry);
+    return entry;
+}
+function persistStageState(prefix, version, entry) {
+    try {
+        let state = ProjectStore.loadStageState(prefix, version);
+        if (!state) {
+            ProjectStore.initProject(prefix, version, {
+                mcpVersion: `project-service-v${PROJECT_SERVICE_VERSION}`,
+            });
+            state = ProjectStore.loadStageState(prefix, version);
+            if (!state)
+                return;
+        }
+        if (state.archived) {
+            return;
+        }
+        state.stage = entry.stage;
+        state.updated_at = entry.updated_at;
+        ProjectStore.saveStageState(prefix, version, state);
+    }
+    catch {
+    }
+}
+export function getProjectStatus(prefix, version) {
+    const entry = getStageCache(prefix, version);
+    const stage = entry?.stage ?? 1;
+    const stageInfo = {
+        1: { name: "Project Naming", description: "Project namespace established. Ready to analyze business intent.", next: "analyze_intent" },
+        2: { name: "Business Puzzle", description: "Business intent analyzed. Puzzles may need completion before risk assessment.", next: entry?.puzzles ? "aggregate_risks" : "analyze_intent" },
+        3: { name: "Risk Calibration", description: "Risks assessed. Fix CRITICAL risks before generating deployment doc.", next: entry?.risk_can_proceed ? "generate_deployment_doc" : "aggregate_risks" },
+        4: { name: "Deployment Document", description: "Deployment doc generated. Fix D-errors before substep trace.", next: entry?.doc_error_count === 0 ? "trace_substeps" : "generate_deployment_doc" },
+        5: { name: "Substep Trace", description: "Substeps traced. Ready for deployment execution.", next: entry?.trace_can_proceed ? "deploy" : "trace_substeps" },
+    };
+    const info = stageInfo[stage];
+    return {
+        stage,
+        stage_name: info.name,
+        stage_description: info.description,
+        next_action: info.next,
+        can_proceed: stage < 5,
+        details: entry,
+    };
+}
+export function clearStageCache(prefix, version) {
+    STAGE_CACHE.delete(stageCacheKey(prefix, version));
+}
 export function normalize(input) {
     if (!isProjectServiceEnabled()) {
         return { data: input.data, warnings: [] };

package/dist/project/migration.d.ts

@@ -0,0 +1,22 @@
+export interface MigrationStep {
+    from: string;
+    to: string;
+    description: string;
+    migrate: (projectDirPath: string) => void;
+}
+export interface MigrationResult {
+    migrated: boolean;
+    from_version: string;
+    to_version: string;
+    steps_executed: string[];
+    backup_path?: string;
+    needs_recalibration: boolean;
+    message: string;
+}
+export declare function migrateProject(prefix: string, version: string): MigrationResult;
+export declare function needsMigration(prefix: string, version: string): boolean;
+export declare function listAvailableMigrations(): Array<{
+    from: string;
+    to: string;
+    description: string;
+}>;

package/dist/project/migration.js

@@ -0,0 +1,125 @@
+import { copyFileSync, mkdirSync, readdirSync } from "fs";
+import { join } from "path";
+import { CURRENT_SCHEMA_VERSION, projectDir, loadManifest, saveManifest, } from "./project-store.js";
+const MIGRATIONS = [];
+function backupProject(prefix, version) {
+    const srcDir = projectDir(prefix, version);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupDir = join(srcDir, ".backup", timestamp);
+    mkdirSync(backupDir, { recursive: true });
+    function copyDir(srcRel) {
+        const srcAbs = join(srcDir, srcRel);
+        const items = readdirSync(srcAbs, { withFileTypes: true });
+        for (const item of items) {
+            if (srcRel === "" && item.name === ".backup")
+                continue;
+            const rel = srcRel ? join(srcRel, item.name) : item.name;
+            const abs = join(srcDir, rel);
+            if (item.isDirectory()) {
+                mkdirSync(join(backupDir, rel), { recursive: true });
+                copyDir(rel);
+            }
+            else if (item.isFile()) {
+                copyFileSync(abs, join(backupDir, rel));
+            }
+        }
+    }
+    copyDir("");
+    return backupDir;
+}
+export function migrateProject(prefix, version) {
+    const manifest = loadManifest(prefix, version);
+    const fromVersion = manifest.schema_version;
+    if (fromVersion === CURRENT_SCHEMA_VERSION) {
+        return {
+            migrated: false,
+            from_version: fromVersion,
+            to_version: CURRENT_SCHEMA_VERSION,
+            steps_executed: [],
+            needs_recalibration: manifest.needs_recalibration ?? false,
+            message: `Project schema is up-to-date (${fromVersion}). No migration needed.`,
+        };
+    }
+    const backupPath = backupProject(prefix, version);
+    const dir = projectDir(prefix, version);
+    const stepsExecuted = [];
+    let current = fromVersion;
+    let safetyCounter = 0;
+    const MAX_STEPS = 50;
+    while (current !== CURRENT_SCHEMA_VERSION && safetyCounter < MAX_STEPS) {
+        const step = MIGRATIONS.find((m) => m.from === current);
+        if (!step) {
+            const updatedManifest = {
+                ...manifest,
+                needs_recalibration: true,
+                updated_at: new Date().toISOString(),
+            };
+            saveManifest(prefix, version, updatedManifest);
+            return {
+                migrated: false,
+                from_version: fromVersion,
+                to_version: current,
+                steps_executed: stepsExecuted,
+                backup_path: backupPath,
+                needs_recalibration: true,
+                message: `No migration path from schema ${current} to ${CURRENT_SCHEMA_VERSION}. ` +
+                    `Project backed up to ${backupPath}. Manual recalibration required.`,
+            };
+        }
+        try {
+            step.migrate(dir);
+            stepsExecuted.push(`${step.from}→${step.to}: ${step.description}`);
+            current = step.to;
+        }
+        catch (e) {
+            const updatedManifest = {
+                ...manifest,
+                needs_recalibration: true,
+                updated_at: new Date().toISOString(),
+            };
+            saveManifest(prefix, version, updatedManifest);
+            return {
+                migrated: false,
+                from_version: fromVersion,
+                to_version: current,
+                steps_executed: stepsExecuted,
+                backup_path: backupPath,
+                needs_recalibration: true,
+                message: `Migration ${step.from}→${step.to} failed: ${e instanceof Error ? e.message : String(e)}. ` +
+                    `Project backed up to ${backupPath}. Manual intervention required.`,
+            };
+        }
+        safetyCounter++;
+    }
+    const updatedManifest = {
+        ...manifest,
+        schema_version: CURRENT_SCHEMA_VERSION,
+        needs_recalibration: true,
+        updated_at: new Date().toISOString(),
+    };
+    saveManifest(prefix, version, updatedManifest);
+    return {
+        migrated: true,
+        from_version: fromVersion,
+        to_version: CURRENT_SCHEMA_VERSION,
+        steps_executed: stepsExecuted,
+        backup_path: backupPath,
+        needs_recalibration: true,
+        message: `Project migrated from schema ${fromVersion} to ${CURRENT_SCHEMA_VERSION}. ` +
+            `${stepsExecuted.length} migration step(s) executed. ` +
+            `Recalibration recommended: re-run aggregate_risks and generate_deployment_doc. ` +
+            `Backup saved to ${backupPath}.`,
+    };
+}
+export function needsMigration(prefix, version) {
+    try {
+        const manifest = loadManifest(prefix, version);
+        return manifest.schema_version !== CURRENT_SCHEMA_VERSION;
+    }
+    catch {
+        return false;
+    }
+}
+export function listAvailableMigrations() {
+    return MIGRATIONS.map((m) => ({ from: m.from, to: m.to, description: m.description }));
+}

package/dist/project/project-store.d.ts

@@ -0,0 +1,110 @@
+export declare const CURRENT_SCHEMA_VERSION = "1.0.0";
+export declare function projectsRootDir(): string;
+export declare function projectDir(prefix: string, version: string): string;
+export declare function deploymentDir(prefix: string, version: string): string;
+export interface ProjectManifest {
+    schema_version: string;
+    mcp_version: string;
+    prefix: string;
+    version: string;
+    created_at: string;
+    updated_at: string;
+    forked_from?: string;
+    needs_recalibration?: boolean;
+}
+export type ProjectStage = 1 | 2 | 3 | 4 | 5;
+export interface StageState {
+    stage: ProjectStage;
+    updated_at: number;
+    stage_meta: Record<ProjectStage, {
+        committed: boolean;
+        committed_at?: number;
+        gate_passed: boolean;
+        blocking_issues: string[];
+        completion: number;
+    }>;
+    has_published_object: boolean;
+    archived: boolean;
+}
+export type AuditEventType = "stage_commit" | "stage_rollback" | "risk_acknowledged" | "fork_created" | "migration_applied" | "gate_validation" | "object_published";
+export interface AuditRecord {
+    timestamp: string;
+    event: AuditEventType;
+    stage?: ProjectStage;
+    reason: string;
+    affected_files: string[];
+    user_confirmed?: boolean;
+}
+export declare function ensureProjectDir(prefix: string, version: string): string;
+export declare function initProject(prefix: string, version: string, options?: {
+    mcpVersion?: string;
+    forkedFrom?: string;
+}): ProjectManifest;
+export declare function loadManifest(prefix: string, version: string): ProjectManifest;
+export declare function saveManifest(prefix: string, version: string, manifest: ProjectManifest): void;
+export declare function loadStageState(prefix: string, version: string): StageState | undefined;
+export declare function saveStageState(prefix: string, version: string, state: StageState): void;
+export declare function saveProjectFile(prefix: string, version: string, relPath: string, data: unknown): string;
+export declare function loadProjectFile<T = unknown>(prefix: string, version: string, relPath: string): T | undefined;
+export declare function saveProjectMarkdown(prefix: string, version: string, relPath: string, markdown: string): string;
+export declare function appendJsonl(prefix: string, version: string, relPath: string, record: unknown): string;
+export declare function appendAudit(prefix: string, version: string, record: AuditRecord): void;
+export declare function readAuditLog(prefix: string, version: string): AuditRecord[];
+export interface LocalProjectEntry {
+    dir_name: string;
+    prefix: string;
+    version: string;
+    path: string;
+    initialized: boolean;
+    archived: boolean;
+    needs_migration: boolean;
+    forked_from?: string;
+    mtime: number;
+}
+export declare function parseProjectDirName(dirName: string): {
+    prefix: string;
+    version: string;
+} | undefined;
+export declare function listLocalProjects(): LocalProjectEntry[];
+export declare function projectExists(prefix: string, version: string): boolean;
+export interface ForkOptions {
+    newVersion: string;
+    newPrefix?: string;
+    mcpVersion?: string;
+}
+export interface ForkResult {
+    new_prefix: string;
+    new_version: string;
+    new_path: string;
+    forked_from: string;
+    copied_files: string[];
+}
+export declare function forkProject(srcPrefix: string, srcVersion: string, opts: ForkOptions): ForkResult;
+export interface ProjectFileEntry {
+    path: string;
+    abs_path: string;
+    size: number;
+    mtime: number;
+    kind: "json" | "markdown" | "jsonl" | "other";
+}
+export declare function listProjectFiles(prefix: string, version: string): ProjectFileEntry[];
+export declare function readProjectFile(prefix: string, version: string, relPath: string): string | undefined;
+export declare function commitStage(prefix: string, version: string, stage: ProjectStage, options?: {
+    gatePassed?: boolean;
+    blockingIssues?: string[];
+    completion?: number;
+    reason?: string;
+    userConfirmed?: boolean;
+}): StageState;
+export declare function rollbackStage(prefix: string, version: string, toStage: ProjectStage, options?: {
+    reason?: string;
+    affectedFiles?: string[];
+}): StageState;
+export declare function markObjectPublished(prefix: string, version: string, objectName: string): void;
+export interface ProjectSyncStatus {
+    local_exists: boolean;
+    initialized: boolean;
+    needs_migration: boolean;
+    archived: boolean;
+}
+export declare function getLocalSyncStatus(prefix: string, version: string): ProjectSyncStatus;