devsmind-mcp 2.2.2 → 2.3.0

package/dist/db/database.d.ts

@@ -1,4 +1,5 @@
-import { DbNode, DbHistory, DbConnection } from './schema';
+import { DbNode, DbHistory, DbConnection, DbWorkflow, DbWorkflowStep, DbWorkflowArtifact } from './schema';
+import { ProjectContext } from '../utils/config';
 export interface ReasoningObject {
     what_changed: string;
     why: string;
@@ -48,6 +49,7 @@ export declare class DevMindDatabase {
     private context;
     constructor(dbPath: string);
     private initSchema;
+    getContext(): ProjectContext | null;
     getSystemMeta(key: string): string | null;
     setSystemMeta(key: string, value: string): void;
     getNodesByFilePath(filePath: string): DbNode[];
@@ -88,7 +90,8 @@ export declare class DevMindDatabase {
     getNode(id: string): DbNode | null;
     deleteNode(id: string): void;
     deprecateNode(id: string): void;
-    renameNode(oldId: string, newId: string, newName?: string): void;
+    /** `newFilePath`: pass when the rename is a file move (analyze's rename migration), leave undefined for a pure symbol-id rename where the file itself is unchanged. */
+    renameNode(oldId: string, newId: string, newName?: string, newFilePath?: string): void;
     /**
      * Rewrites a history/[id].json file's identifying fields (node_id, node_metadata) in
      * place, leaving code_snapshot/reasoning/timestamps untouched. Used after a rename so
@@ -224,6 +227,135 @@ export declare class DevMindDatabase {
     }): DbNode[];
     getAllConnections(): DbConnection[];
     getAllHistory(): DbHistory[];
+    /** Nodes whose total (in + out) connection degree meets/exceeds `threshold` — architectural bottleneck candidates. */
+    getGodEntities(threshold?: number): {
+        id: string;
+        name: string;
+        file_path: string;
+        degree: number;
+    }[];
+    /** DFS cycle detection over the connection graph, capped at `maxCycles` reported paths. */
+    getCircularDependencies(maxCycles?: number): string[][];
+    /** node_connections rows whose source or target no longer exists in `nodes` (broken by a non-transactional delete, or a sync race). */
+    getDanglingEdges(): DbConnection[];
+    /** Deletes a single dangling `node_connections` row. The edge itself is invalid data — no history/graph JSON to rewrite. */
+    deleteDanglingEdge(sourceId: string, targetId: string): void;
+    /** Node ids that differ only by case — a real collision risk on Windows's case-insensitive filesystem. */
+    getDuplicateNodeIds(): {
+        lowerId: string;
+        ids: string[];
+    }[];
+    /** History rows whose flattened `reasoning` text has no non-empty `Developer:` line — can't be attributed to anyone. */
+    getHistoryMissingDeveloper(): {
+        id: string;
+        node_id: string;
+        updated_at: string;
+    }[];
+    /**
+     * History rows with a blank code snapshot — usually a silent AST extraction failure.
+     * The `history.code_snapshot` DB column is always written as `''` (the real content
+     * lives only in the per-row JSON on disk, see `populateHistoryFromDisk`), so this
+     * must read through the populated rows rather than querying the column directly.
+     */
+    getEmptyCodeSnapshots(): {
+        id: string;
+        node_id: string;
+        updated_at: string;
+    }[];
+    private workflowsDir;
+    /** Serializes the workflow + its steps + artifact index to disk so teammates can sync it via git. */
+    private writeWorkflowToDisk;
+    createWorkflow(name: string, description: string): DbWorkflow;
+    getWorkflow(id: string): DbWorkflow | null;
+    getActiveWorkflow(): DbWorkflow | null;
+    listWorkflows(status?: 'active' | 'paused' | 'completed'): DbWorkflow[];
+    /** Pauses the currently active workflow (if any) and clears the active pointer. */
+    pauseWorkflow(): DbWorkflow | null;
+    /** Resumes `id`, auto-pausing whatever was previously active (only one workflow is active at a time). */
+    resumeWorkflow(id: string): DbWorkflow;
+    completeWorkflow(id: string): DbWorkflow;
+    addWorkflowStep(workflowId: string, opts: {
+        summary: string;
+        pendingTasks?: string;
+        historyIds?: string[];
+        sessionId?: string;
+    }): DbWorkflowStep;
+    /** Writes `content` to `.devmind/workflows/<workflowId>/<artifactId>_<sourceName>` and records the DB row. */
+    addWorkflowArtifact(workflowId: string, opts: {
+        stepId?: string;
+        type: string;
+        sourceName: string;
+        content: string;
+    }): DbWorkflowArtifact;
+    getWorkflowContext(id: string, opts?: {
+        includeArtifactContent?: boolean;
+    }): {
+        workflow: DbWorkflow;
+        steps: DbWorkflowStep[];
+        artifacts: (DbWorkflowArtifact & {
+            content?: string;
+        })[];
+    };
+    /**
+     * Returns steps for a workflow with optional pagination.
+     * Use `last_n` to get only the most recent N steps (tail), or `limit`/`offset` for
+     * arbitrary pagination. Without any option, all steps are returned.
+     */
+    getWorkflowSteps(workflowId: string, opts?: {
+        limit?: number;
+        offset?: number;
+        last_n?: number;
+    }): DbWorkflowStep[];
+    /**
+     * Reads a single workflow artifact's file content from disk.
+     * Accepts either an artifact_id or a source_name (first match used).
+     */
+    readWorkflowArtifact(workflowId: string, artifactId: string): {
+        artifact: DbWorkflowArtifact;
+        content: string;
+    };
+    /**
+     * Full-text keyword search across all workflows' step summaries, pending_tasks,
+     * and artifact source names. Optionally also searches artifact file content.
+     * Returns a list of matches grouped by workflow.
+     */
+    searchWorkflows(query: string, opts?: {
+        include_artifact_content?: boolean;
+        status?: 'active' | 'paused' | 'completed';
+    }): Array<{
+        workflow: DbWorkflow;
+        matched_steps: DbWorkflowStep[];
+        matched_artifacts: (DbWorkflowArtifact & {
+            content_snippet?: string;
+        })[];
+    }>;
+    /**
+     * Imports an existing flow/architecture doc as a paused workflow (not active — importing
+     * a doc isn't the same as declaring active work). Idempotent on `name`: re-importing the
+     * same doc overwrites its existing `imported_doc` artifact file in place instead of
+     * creating a duplicate workflow every time the source docs are re-imported.
+     */
+    importWorkflowDoc(name: string, description: string, content: string, sourceFileName: string): {
+        workflow: DbWorkflow;
+        created: boolean;
+    };
+    private static readonly SPURIOUS_NODE_NAMES;
+    /**
+     * Read-only detection shared by `pruneSpuriousNodes` (which acts on it) and `devsmind
+     * analyze`'s dry-run report (which just lists it). Never mutates the DB.
+     */
+    findSpuriousAndMissingFileNodes(workspaceRoot: string): {
+        spurious: {
+            id: string;
+            name: string;
+            file_path: string;
+        }[];
+        missingFile: {
+            id: string;
+            name: string;
+            file_path: string;
+        }[];
+    };
     pruneSpuriousNodes(workspaceRoot: string): {
         prunedCount: number;
         prunedNodes: string[];
@@ -231,9 +363,26 @@ export declare class DevMindDatabase {
     private populateHistoryFromDisk;
     private writeHistoryToDisk;
     toRepoRelativePath(absolutePath: string): string;
+    /**
+     * Rejects a resolved path that escapes its expected root (e.g. via a stored
+     * `{repo}/../../..` path traveling outside the repo) by clamping it back to
+     * the root itself. node_id/file_path values flow in from AI-supplied tool
+     * calls, so a resolve must never be trusted to stay inside root on its own.
+     */
+    private clampToRoot;
+    /**
+     * True if `absPath` sits inside a configured repo root or the workspace root itself.
+     * Used to reject `stage_change`/`update_history` file paths that would otherwise let a
+     * tool call read/write any file on disk (absolute path, or a `../` escape) instead of
+     * just repo source — nothing upstream of this validates that the AI-supplied path is
+     * actually inside the project.
+     */
+    isPathAllowed(absPath: string): boolean;
     toAbsolutePath(repoRelativePath: string): string;
     syncFromDisk(): void;
     /** Escape LIKE metacharacters so a path is matched literally (use with ESCAPE '\\'). */
     private likeEscape;
     writeGraphToDisk(filePath: string): void;
+    /** Force-syncs all database nodes and workflows to disk JSON files. */
+    syncToDisk(): void;
 }