mdkg 0.1.6 → 0.1.7

package/dist/commands/work.js

@@ -56,6 +56,13 @@ function normalizePortableId(value, flag) {
     }
     return normalized;
 }
+function normalizePortableIdRef(value, flag) {
+    const normalized = value.toLowerCase();
+    if (!(0, id_1.isPortableIdRef)(normalized)) {
+        throw new errors_1.UsageError(`${flag} must be a lowercase portable id or qid`);
+    }
+    return normalized;
+}
 function normalizeEnum(value, flag, allowed) {
     const normalized = value.toLowerCase();
     if (!allowed.has(normalized)) {
@@ -95,20 +102,14 @@ function maybeReindex(root, config) {
     }
     (0, reindex_1.writeDerivedIndexes)(root, config, (0, indexer_1.buildIndex)(root, config, { tolerant: config.index.tolerant }));
 }
-function findNodeById(index, ws, id, type) {
-    const node = index.nodes[`${ws}:${id}`];
-    if (!node) {
-        return undefined;
-    }
-    if (type && node.type !== type) {
-        return undefined;
+function requireReferenceNode(index, ws, idOrQid, type, label) {
+    const resolved = (0, qid_1.resolveQid)(index, idOrQid, ws);
+    if (resolved.status !== "ok") {
+        throw new errors_1.NotFoundError((0, qid_1.formatResolveError)(label, idOrQid, resolved, ws));
     }
-    return node;
-}
-function requireNodeById(index, ws, id, type, label) {
-    const node = findNodeById(index, ws, id, type);
-    if (!node) {
-        throw new errors_1.NotFoundError(`${label} not found: ${id}`);
+    const node = index.nodes[resolved.qid];
+    if (!node || node.type !== type) {
+        throw new errors_1.NotFoundError(`${label} not found: ${idOrQid}`);
     }
     return node;
 }
@@ -214,8 +215,9 @@ function runWorkContractNewCommandLocked(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
     const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
-    const agentId = normalizePortableId(options.agentId, "--agent-id");
-    const relates = findNodeById(index, ws, agentId, "spec") ? [agentId] : [];
+    const agentId = normalizePortableIdRef(options.agentId, "--agent-id");
+    const resolvedAgent = (0, qid_1.resolveQid)(index, agentId, ws);
+    const relates = resolvedAgent.status === "ok" && index.nodes[resolvedAgent.qid]?.type === "spec" ? [agentId] : [];
     const receipt = createAgentWorkflowNode({
         root: options.root,
         ws,
@@ -240,8 +242,8 @@ function runWorkOrderNewCommandLocked(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
     const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
-    const workId = normalizePortableId(options.workId, "--work-id");
-    const workNode = requireNodeById(index, ws, workId, "work", "work contract");
+    const workId = normalizePortableIdRef(options.workId, "--work-id");
+    const workNode = requireReferenceNode(index, ws, workId, "work", "work contract");
     const workVersion = String(workNode.attributes.version ?? "0.1.0");
     const receipt = createAgentWorkflowNode({
         root: options.root,
@@ -281,8 +283,8 @@ function runWorkReceiptNewCommandLocked(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
     const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
-    const workOrderId = normalizePortableId(options.workOrderId, "--work-order-id");
-    requireNodeById(index, ws, workOrderId, "work_order", "work order");
+    const workOrderId = normalizePortableIdRef(options.workOrderId, "--work-order-id");
+    requireReferenceNode(index, ws, workOrderId, "work_order", "work order");
     const receipt = createAgentWorkflowNode({
         root: options.root,
         ws,

package/dist/core/config.js

@@ -9,6 +9,7 @@ const fs_1 = __importDefault(require("fs"));
 const paths_1 = require("./paths");
 const migrate_1 = require("./migrate");
 const workspace_path_1 = require("./workspace_path");
+const project_db_1 = require("./project_db");
 const WORKSPACE_ALIAS_RE = /^[a-z][a-z0-9_]*$/;
 const PACK_EDGE_KEYS = new Set([
     "parent",
@@ -24,10 +25,22 @@ const WORKSPACE_VISIBILITY_VALUES = new Set(["private", "internal", "public"]);
 const BUNDLE_PROFILE_VALUES = new Set(["private", "public"]);
 const INDEX_BACKEND_VALUES = new Set(["json", "sqlite"]);
 const SUBGRAPH_PERMISSION_VALUES = new Set(["read", "request", "propose", "mutate"]);
+const SQL_IDENTIFIER_RE = /^[a-z][a-z0-9_]*$/;
 const DEFAULT_ARCHIVE_LARGE_CACHE_WARNING_BYTES = 26214400;
 const DEFAULT_SQLITE_COMMIT_WARNING_BYTES = 52428800;
 const DEFAULT_LOCK_TIMEOUT_MS = 10000;
 const DEFAULT_SUBGRAPH_MAX_STALE_SECONDS = 3600;
+const DEFAULT_PROJECT_DB_CONFIG = {
+    enabled: false,
+    schema_version: project_db_1.PROJECT_DB_CONFIG_SCHEMA_VERSION,
+    root_path: project_db_1.PROJECT_DB_RELATIVE_DIR,
+    schema_path: project_db_1.PROJECT_DB_SCHEMA_DIR,
+    migrations_path: project_db_1.PROJECT_DB_MIGRATIONS_DIR,
+    runtime_path: project_db_1.PROJECT_DB_RUNTIME_FILE,
+    state_path: project_db_1.PROJECT_DB_STATE_FILE,
+    receipts_path: project_db_1.PROJECT_DB_RECEIPTS_DIR,
+    migration_table: project_db_1.PROJECT_DB_MIGRATION_TABLE,
+};
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -200,6 +213,40 @@ function requireContainedPath(value, path, errors) {
         return undefined;
     }
 }
+function requireSqlIdentifier(value, path, errors) {
+    const raw = requireString(value, path, errors);
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (!SQL_IDENTIFIER_RE.test(raw)) {
+        errors.push(`${path} must be a lowercase SQL identifier using [a-z0-9_]`);
+        return undefined;
+    }
+    return raw;
+}
+function isContainedConfigPath(rootPath, candidate) {
+    return candidate === rootPath || candidate.startsWith(`${rootPath}/`);
+}
+function defaultProjectDbChildPath(rootPath, suffix, fallback) {
+    if (!rootPath) {
+        return fallback;
+    }
+    if (rootPath === ".") {
+        return suffix;
+    }
+    return `${rootPath}/${suffix}`;
+}
+function requireProjectDbPath(value, path, rootPath, errors) {
+    const normalized = requireContainedPath(value, path, errors);
+    if (normalized === undefined || rootPath === undefined) {
+        return normalized;
+    }
+    if (!isContainedConfigPath(rootPath, normalized)) {
+        errors.push(`${path} must be inside db.root_path`);
+        return undefined;
+    }
+    return normalized;
+}
 function validateConfigSchema(raw) {
     const errors = [];
     if (!isObject(raw)) {
@@ -218,6 +265,7 @@ function validateConfigSchema(raw) {
     const bundlesRaw = raw.bundles === undefined
         ? { output_dir: ".mdkg/bundles", default_profile: "private" }
         : requireObject(raw.bundles, "bundles", errors);
+    const dbRaw = raw.db === undefined ? DEFAULT_PROJECT_DB_CONFIG : requireObject(raw.db, "db", errors);
     if (raw.bundle_imports !== undefined && raw.subgraphs !== undefined) {
         errors.push("config must not define both subgraphs and legacy bundle_imports");
     }
@@ -268,6 +316,60 @@ function validateConfigSchema(raw) {
             default_profile: requireStringInSet(bundlesRaw.default_profile, "bundles.default_profile", BUNDLE_PROFILE_VALUES, errors),
         }
         : undefined;
+    let db;
+    if (dbRaw) {
+        if ("profile" in dbRaw || "profiles" in dbRaw || "profile_name" in dbRaw) {
+            errors.push("db profiles are not supported in this release");
+        }
+        const dbEnabled = dbRaw.enabled === undefined
+            ? DEFAULT_PROJECT_DB_CONFIG.enabled
+            : requireBoolean(dbRaw.enabled, "db.enabled", errors);
+        const dbSchemaVersion = dbRaw.schema_version === undefined
+            ? DEFAULT_PROJECT_DB_CONFIG.schema_version
+            : requirePositiveInteger(dbRaw.schema_version, "db.schema_version", errors);
+        const dbRootPath = dbRaw.root_path === undefined
+            ? DEFAULT_PROJECT_DB_CONFIG.root_path
+            : requireContainedPath(dbRaw.root_path, "db.root_path", errors);
+        const dbSchemaPath = requireProjectDbPath(dbRaw.schema_path === undefined
+            ? defaultProjectDbChildPath(dbRootPath, "schema", DEFAULT_PROJECT_DB_CONFIG.schema_path)
+            : dbRaw.schema_path, "db.schema_path", dbRootPath, errors);
+        const dbMigrationsPath = requireProjectDbPath(dbRaw.migrations_path === undefined
+            ? defaultProjectDbChildPath(dbRootPath, "schema/migrations", DEFAULT_PROJECT_DB_CONFIG.migrations_path)
+            : dbRaw.migrations_path, "db.migrations_path", dbRootPath, errors);
+        const dbRuntimePath = requireProjectDbPath(dbRaw.runtime_path === undefined
+            ? defaultProjectDbChildPath(dbRootPath, "runtime/project.sqlite", DEFAULT_PROJECT_DB_CONFIG.runtime_path)
+            : dbRaw.runtime_path, "db.runtime_path", dbRootPath, errors);
+        const dbStatePath = requireProjectDbPath(dbRaw.state_path === undefined
+            ? defaultProjectDbChildPath(dbRootPath, "state/project.sqlite", DEFAULT_PROJECT_DB_CONFIG.state_path)
+            : dbRaw.state_path, "db.state_path", dbRootPath, errors);
+        const dbReceiptsPath = requireProjectDbPath(dbRaw.receipts_path === undefined
+            ? defaultProjectDbChildPath(dbRootPath, "receipts", DEFAULT_PROJECT_DB_CONFIG.receipts_path)
+            : dbRaw.receipts_path, "db.receipts_path", dbRootPath, errors);
+        const dbMigrationTable = dbRaw.migration_table === undefined
+            ? DEFAULT_PROJECT_DB_CONFIG.migration_table
+            : requireSqlIdentifier(dbRaw.migration_table, "db.migration_table", errors);
+        if (dbEnabled !== undefined &&
+            dbSchemaVersion !== undefined &&
+            dbRootPath &&
+            dbSchemaPath &&
+            dbMigrationsPath &&
+            dbRuntimePath &&
+            dbStatePath &&
+            dbReceiptsPath &&
+            dbMigrationTable) {
+            db = {
+                enabled: dbEnabled,
+                schema_version: dbSchemaVersion,
+                root_path: dbRootPath,
+                schema_path: dbSchemaPath,
+                migrations_path: dbMigrationsPath,
+                runtime_path: dbRuntimePath,
+                state_path: dbStatePath,
+                receipts_path: dbReceiptsPath,
+                migration_table: dbMigrationTable,
+            };
+        }
+    }
     const packLimitsRaw = packRaw ? requireObject(packRaw.limits, "pack.limits", errors) : undefined;
     const pack = packRaw
         ? {
@@ -502,6 +604,7 @@ function validateConfigSchema(raw) {
         index: index,
         capabilities: capabilities,
         bundles: bundles,
+        db: db,
         subgraphs,
         pack: pack,
         templates: templates,

package/dist/core/project_db.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROJECT_DB_GITIGNORE_ENTRIES = exports.PROJECT_DB_SUBDIRS = exports.PROJECT_DB_MIGRATION_TABLE = exports.PROJECT_DB_CONFIG_SCHEMA_VERSION = exports.PROJECT_DB_MANIFEST_FILE = exports.PROJECT_DB_STATE_MANIFEST_FILE = exports.PROJECT_DB_STATE_FILE = exports.PROJECT_DB_RUNTIME_FILE = exports.PROJECT_DB_RECEIPTS_DIR = exports.PROJECT_DB_STATE_DIR = exports.PROJECT_DB_RUNTIME_DIR = exports.PROJECT_DB_MIGRATIONS_DIR = exports.PROJECT_DB_SCHEMA_DIR = exports.PROJECT_DB_RELATIVE_DIR = void 0;
+exports.resolveProjectDbLayout = resolveProjectDbLayout;
+exports.resolveConfiguredProjectDbLayout = resolveConfiguredProjectDbLayout;
+exports.listProjectDbRuntimePolicyFiles = listProjectDbRuntimePolicyFiles;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.PROJECT_DB_RELATIVE_DIR = ".mdkg/db";
+exports.PROJECT_DB_SCHEMA_DIR = ".mdkg/db/schema";
+exports.PROJECT_DB_MIGRATIONS_DIR = ".mdkg/db/schema/migrations";
+exports.PROJECT_DB_RUNTIME_DIR = ".mdkg/db/runtime";
+exports.PROJECT_DB_STATE_DIR = ".mdkg/db/state";
+exports.PROJECT_DB_RECEIPTS_DIR = ".mdkg/db/receipts";
+exports.PROJECT_DB_RUNTIME_FILE = ".mdkg/db/runtime/project.sqlite";
+exports.PROJECT_DB_STATE_FILE = ".mdkg/db/state/project.sqlite";
+exports.PROJECT_DB_STATE_MANIFEST_FILE = ".mdkg/db/state/project.manifest.json";
+exports.PROJECT_DB_MANIFEST_FILE = ".mdkg/db/project-db.json";
+exports.PROJECT_DB_CONFIG_SCHEMA_VERSION = 1;
+exports.PROJECT_DB_MIGRATION_TABLE = "mdkg_schema_migration";
+exports.PROJECT_DB_SUBDIRS = [
+    exports.PROJECT_DB_SCHEMA_DIR,
+    exports.PROJECT_DB_MIGRATIONS_DIR,
+    exports.PROJECT_DB_RUNTIME_DIR,
+    exports.PROJECT_DB_STATE_DIR,
+    exports.PROJECT_DB_RECEIPTS_DIR,
+];
+exports.PROJECT_DB_GITIGNORE_ENTRIES = [
+    ".mdkg/db/runtime/",
+    ".mdkg/db/**/*.sqlite-wal",
+    ".mdkg/db/**/*.sqlite-shm",
+    ".mdkg/db/**/*.sqlite-journal",
+    ".mdkg/db/**/*.lock",
+    ".mdkg/db/**/*.tmp",
+];
+const TRANSIENT_SUFFIXES = [
+    "-wal",
+    "-shm",
+    "-journal",
+    ".lock",
+    ".tmp",
+];
+function toPosix(relativePath) {
+    return relativePath.split(path_1.default.sep).join("/");
+}
+function walkFiles(root) {
+    if (!fs_1.default.existsSync(root)) {
+        return [];
+    }
+    const entries = fs_1.default.readdirSync(root, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path_1.default.join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...walkFiles(fullPath));
+        }
+        else if (entry.isFile()) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function resolveProjectDbLayout(root) {
+    return {
+        root,
+        db: path_1.default.resolve(root, exports.PROJECT_DB_RELATIVE_DIR),
+        schema: path_1.default.resolve(root, exports.PROJECT_DB_SCHEMA_DIR),
+        migrations: path_1.default.resolve(root, exports.PROJECT_DB_MIGRATIONS_DIR),
+        runtime: path_1.default.resolve(root, exports.PROJECT_DB_RUNTIME_DIR),
+        state: path_1.default.resolve(root, exports.PROJECT_DB_STATE_DIR),
+        receipts: path_1.default.resolve(root, exports.PROJECT_DB_RECEIPTS_DIR),
+    };
+}
+function resolveConfiguredProjectDbLayout(root, config) {
+    const runtimeFile = path_1.default.resolve(root, config.runtime_path);
+    const stateFile = path_1.default.resolve(root, config.state_path);
+    const stateManifest = path_1.default.join(path_1.default.dirname(stateFile), `${path_1.default.basename(stateFile, path_1.default.extname(stateFile))}.manifest.json`);
+    return {
+        root,
+        db: path_1.default.resolve(root, config.root_path),
+        schema: path_1.default.resolve(root, config.schema_path),
+        migrations: path_1.default.resolve(root, config.migrations_path),
+        runtimeFile,
+        runtimeDir: path_1.default.dirname(runtimeFile),
+        stateFile,
+        stateManifest,
+        stateDir: path_1.default.dirname(stateFile),
+        receipts: path_1.default.resolve(root, config.receipts_path),
+        manifest: path_1.default.resolve(root, config.root_path, "project-db.json"),
+    };
+}
+function listProjectDbRuntimePolicyFiles(root) {
+    const layout = resolveProjectDbLayout(root);
+    const dbFiles = walkFiles(layout.db);
+    return dbFiles
+        .filter((filePath) => {
+        if (filePath.startsWith(`${layout.runtime}${path_1.default.sep}`)) {
+            return true;
+        }
+        const basename = path_1.default.basename(filePath);
+        return TRANSIENT_SUFFIXES.some((suffix) => basename.endsWith(suffix));
+    })
+        .map((filePath) => toPosix(path_1.default.relative(root, filePath)))
+        .sort();
+}