comisai 1.0.10 → 1.0.12

package/node_modules/@comis/core/dist/bootstrap.test.d.ts

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

package/node_modules/@comis/core/dist/bootstrap.test.js

@@ -1,150 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { describe, it, expect, afterEach } from "vitest";
-import { bootstrap } from "./bootstrap.js";
-describe("bootstrap", () => {
-    const tmpDirs = [];
-    const containers = [];
-    function makeTmpDir() {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "comis-bootstrap-"));
-        tmpDirs.push(dir);
-        return dir;
-    }
-    function writeYaml(dir, name, content) {
-        const filePath = path.join(dir, name);
-        fs.writeFileSync(filePath, content, "utf-8");
-        return filePath;
-    }
-    afterEach(async () => {
-        for (const container of containers) {
-            await container.shutdown();
-        }
-        containers.length = 0;
-        for (const dir of tmpDirs) {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-        tmpDirs.length = 0;
-    });
-    it("returns ok with AppContainer for valid config", () => {
-        const dir = makeTmpDir();
-        const configPath = writeYaml(dir, "config.yaml", "tenantId: test\nlogLevel: debug\n");
-        const result = bootstrap({
-            configPaths: [configPath],
-            env: { API_KEY: "secret123" },
-        });
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            containers.push(result.value);
-            expect(result.value.config).toBeDefined();
-            expect(result.value.config.tenantId).toBe("test");
-            expect(result.value.config.logLevel).toBe("debug");
-        }
-    });
-    it("returns err for invalid config", () => {
-        const dir = makeTmpDir();
-        const configPath = writeYaml(dir, "bad.yaml", "logLevel: invalid_level\n");
-        const result = bootstrap({
-            configPaths: [configPath],
-            env: {},
-        });
-        expect(result.ok).toBe(false);
-        if (!result.ok) {
-            expect(result.error.code).toBe("VALIDATION_ERROR");
-        }
-    });
-    it("returns err for missing config file", () => {
-        const result = bootstrap({
-            configPaths: ["/does/not/exist.yaml"],
-            env: {},
-        });
-        expect(result.ok).toBe(false);
-        if (!result.ok) {
-            expect(result.error.code).toBe("FILE_NOT_FOUND");
-        }
-    });
-    it("container.config returns loaded config", () => {
-        const dir = makeTmpDir();
-        const configPath = writeYaml(dir, "config.yaml", "tenantId: my-tenant\n");
-        const result = bootstrap({ configPaths: [configPath], env: {} });
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            containers.push(result.value);
-            expect(result.value.config.tenantId).toBe("my-tenant");
-            expect(result.value.config.agents.default.name).toBe("Comis");
-        }
-    });
-    it("container.eventBus is a TypedEventBus", () => {
-        const dir = makeTmpDir();
-        const configPath = writeYaml(dir, "config.yaml", "tenantId: evtest\n");
-        const result = bootstrap({ configPaths: [configPath], env: {} });
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            containers.push(result.value);
-            // Verify it has TypedEventBus methods
-            expect(typeof result.value.eventBus.on).toBe("function");
-            expect(typeof result.value.eventBus.emit).toBe("function");
-            expect(typeof result.value.eventBus.off).toBe("function");
-        }
-    });
-    it("container.secretManager works with provided env", () => {
-        const dir = makeTmpDir();
-        const configPath = writeYaml(dir, "config.yaml", "tenantId: sectest\n");
-        const result = bootstrap({
-            configPaths: [configPath],
-            env: { MY_SECRET: "s3cr3t", OTHER: "val" },
-        });
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            containers.push(result.value);
-            expect(result.value.secretManager.get("MY_SECRET")).toBe("s3cr3t");
-            expect(result.value.secretManager.has("OTHER")).toBe(true);
-            expect(result.value.secretManager.get("MISSING")).toBeUndefined();
-        }
-    });
-    it("container.shutdown cleans up without errors", async () => {
-        const dir = makeTmpDir();
-        const configPath = writeYaml(dir, "config.yaml", "tenantId: shuttest\n");
-        const result = bootstrap({
-            configPaths: [configPath],
-            env: {},
-        });
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            // Shutdown should not throw
-            await expect(result.value.shutdown()).resolves.toBeUndefined();
-            // Double shutdown should also be safe
-            await expect(result.value.shutdown()).resolves.toBeUndefined();
-        }
-    });
-    it("applies defaults from minimal config content", () => {
-        const dir = makeTmpDir();
-        // Minimal config: empty object
-        const configPath = writeYaml(dir, "minimal.yaml", "{}\n");
-        const result = bootstrap({ configPaths: [configPath], env: {} });
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            containers.push(result.value);
-            const cfg = result.value.config;
-            expect(cfg.tenantId).toBe("default");
-            expect(cfg.logLevel).toBe("info");
-            expect(cfg.dataDir).toBe(path.join(os.homedir(), ".comis"));
-            expect(cfg.agents.default.name).toBe("Comis");
-            expect(cfg.agents.default.maxSteps).toBe(150);
-            expect(cfg.memory.walMode).toBe(true);
-            expect(cfg.security.logRedaction).toBe(true);
-        }
-    });
-    it("merges layered config files", () => {
-        const dir = makeTmpDir();
-        const base = writeYaml(dir, "base.yaml", "tenantId: base\nagents:\n  default:\n    name: BaseBot\n");
-        const local = writeYaml(dir, "local.yaml", "tenantId: local\n");
-        const result = bootstrap({ configPaths: [base, local], env: {} });
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            containers.push(result.value);
-            expect(result.value.config.tenantId).toBe("local");
-            expect(result.value.config.agents.default.name).toBe("BaseBot");
-        }
-    });
-});

package/node_modules/@comis/core/dist/config/backup.test.d.ts

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

package/node_modules/@comis/core/dist/config/backup.test.js

@@ -1,160 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ok, err } from "@comis/shared";
-import { createTimestampedBackup } from "./backup.js";
-/**
- * Helper to build mock BackupDeps with a virtual filesystem.
- */
-function createMockDeps(files, opts) {
-    const removed = [];
-    return {
-        removed,
-        copyFile(src, dest) {
-            if (opts?.copyFail) {
-                return err({
-                    code: "BACKUP_ERROR",
-                    message: `Permission denied: ${dest}`,
-                });
-            }
-            files.add(dest);
-            return ok(undefined);
-        },
-        listDir(dirPath) {
-            if (opts?.listDirFail) {
-                return err({
-                    code: "BACKUP_ERROR",
-                    message: `Cannot list directory: ${dirPath}`,
-                });
-            }
-            const contents = opts?.dirContents ?? [...files].map((f) => {
-                const parts = f.split("/");
-                return parts[parts.length - 1];
-            });
-            return ok(contents);
-        },
-        removeFile(filePath) {
-            if (opts?.removeFail) {
-                return err({
-                    code: "BACKUP_ERROR",
-                    message: `Cannot remove: ${filePath}`,
-                });
-            }
-            removed.push(filePath);
-            files.delete(filePath);
-            return ok(undefined);
-        },
-        fileExists(filePath) {
-            return files.has(filePath);
-        },
-        now() {
-            return new Date("2026-02-12T14:30:00Z");
-        },
-    };
-}
-describe("config/backup", () => {
-    describe("createTimestampedBackup", () => {
-        it("copies source file to backup path with ISO timestamp", () => {
-            const files = new Set(["/config/app.yaml"]);
-            const deps = createMockDeps(files);
-            const result = createTimestampedBackup("/config/app.yaml", deps);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toBe("/config/app.yaml.backup.20260212T143000Z");
-                expect(files.has("/config/app.yaml.backup.20260212T143000Z")).toBe(true);
-            }
-        });
-        it("uses compact ISO format without colons (filesystem-safe)", () => {
-            const files = new Set(["/config/app.yaml"]);
-            const deps = createMockDeps(files);
-            const result = createTimestampedBackup("/config/app.yaml", deps);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                // No colons, dashes only in date part
-                expect(result.value).toMatch(/\.backup\.\d{8}T\d{6}Z$/);
-            }
-        });
-        it("returns Result with the backup file path on success", () => {
-            const files = new Set(["/config/app.yaml"]);
-            const deps = createMockDeps(files);
-            const result = createTimestampedBackup("/config/app.yaml", deps);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(typeof result.value).toBe("string");
-                expect(result.value).toContain("app.yaml.backup.");
-            }
-        });
-        it("returns ConfigError when source file does not exist", () => {
-            const files = new Set();
-            const deps = createMockDeps(files);
-            const result = createTimestampedBackup("/config/missing.yaml", deps);
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("BACKUP_ERROR");
-                expect(result.error.message).toContain("missing.yaml");
-            }
-        });
-        it("returns ConfigError when copy fails (e.g., permissions)", () => {
-            const files = new Set(["/config/app.yaml"]);
-            const deps = createMockDeps(files, { copyFail: true });
-            const result = createTimestampedBackup("/config/app.yaml", deps);
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("BACKUP_ERROR");
-                expect(result.error.message).toContain("Permission denied");
-            }
-        });
-        it("deletes oldest backups when count exceeds maxBackups (default 10)", () => {
-            const files = new Set(["/config/app.yaml"]);
-            // Simulate 10 existing backups + the new one that will be created
-            const dirContents = [];
-            for (let i = 0; i < 10; i++) {
-                const ts = `202602${String(i + 1).padStart(2, "0")}T120000Z`;
-                dirContents.push(`app.yaml.backup.${ts}`);
-            }
-            // The new backup created by the function (injected clock = 2026-02-12T14:30:00Z)
-            dirContents.push("app.yaml.backup.20260212T143000Z");
-            const deps = createMockDeps(files, { dirContents });
-            const result = createTimestampedBackup("/config/app.yaml", deps);
-            expect(result.ok).toBe(true);
-            // 10 existing + 1 new = 11, should prune oldest 1
-            expect(deps.removed.length).toBe(1);
-            expect(deps.removed[0]).toContain("app.yaml.backup.20260201T120000Z");
-        });
-        it("only deletes files matching the backup naming pattern", () => {
-            const files = new Set(["/config/app.yaml"]);
-            const dirContents = [
-                "app.yaml.backup.20260201T120000Z",
-                "app.yaml.backup.20260202T120000Z",
-                "app.yaml", // Not a backup file
-                "other-file.txt", // Not a backup file
-                "app.yaml.backup.20260203T120000Z",
-                "app.yaml.backup.20260212T143000Z", // New backup from this call
-            ];
-            // 3 existing + 1 new = 4 backups, well under default 10
-            const deps = createMockDeps(files, { dirContents });
-            const result = createTimestampedBackup("/config/app.yaml", deps);
-            expect(result.ok).toBe(true);
-            // No backups should be deleted (only 4 backups, well under 10)
-            expect(deps.removed.length).toBe(0);
-        });
-        it("maxBackups is configurable via options parameter", () => {
-            const files = new Set(["/config/app.yaml"]);
-            const dirContents = [];
-            for (let i = 0; i < 5; i++) {
-                const ts = `202602${String(i + 1).padStart(2, "0")}T120000Z`;
-                dirContents.push(`app.yaml.backup.${ts}`);
-            }
-            // The new backup created by the function (injected clock = 2026-02-12T14:30:00Z)
-            dirContents.push("app.yaml.backup.20260212T143000Z");
-            const deps = createMockDeps(files, { dirContents });
-            const result = createTimestampedBackup("/config/app.yaml", deps, {
-                maxBackups: 3,
-            });
-            expect(result.ok).toBe(true);
-            // 5 existing + 1 new = 6, maxBackups=3 → prune 3 oldest
-            expect(deps.removed.length).toBe(3);
-            expect(deps.removed[0]).toContain("20260201T120000Z");
-            expect(deps.removed[1]).toContain("20260202T120000Z");
-            expect(deps.removed[2]).toContain("20260203T120000Z");
-        });
-    });
-});

package/node_modules/@comis/core/dist/config/env-substitution.test.d.ts

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

package/node_modules/@comis/core/dist/config/env-substitution.test.js

@@ -1,259 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { substituteEnvVars, warnSuspiciousEnvValues } from "./env-substitution.js";
-/**
- * Helper: create a simple secret getter from a map.
- */
-function createSecretGetter(secrets) {
-    return (key) => secrets[key];
-}
-describe("config/env-substitution", () => {
-    describe("substituteEnvVars", () => {
-        it("replaces simple ${VAR_NAME} with secret value", () => {
-            const getSecret = createSecretGetter({ API_KEY: "sk-12345" });
-            const obj = { apiKey: "${API_KEY}" };
-            const result = substituteEnvVars(obj, getSecret);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                expect(val.apiKey).toBe("sk-12345");
-            }
-        });
-        it("replaces multiple ${VAR} references in one string", () => {
-            const getSecret = createSecretGetter({
-                HOST: "localhost",
-                PORT: "3000",
-            });
-            const obj = { url: "${HOST}:${PORT}" };
-            const result = substituteEnvVars(obj, getSecret);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                expect(val.url).toBe("localhost:3000");
-            }
-        });
-        it("handles mixed literal and ${VAR} text", () => {
-            const getSecret = createSecretGetter({
-                HOST: "api.example.com",
-                PORT: "8443",
-            });
-            const obj = { endpoint: "https://${HOST}:${PORT}/api" };
-            const result = substituteEnvVars(obj, getSecret);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                expect(val.endpoint).toBe("https://api.example.com:8443/api");
-            }
-        });
-        it("treats $${VAR} escape syntax as literal ${VAR} (no substitution)", () => {
-            const getSecret = createSecretGetter({ VAR: "should-not-appear" });
-            const obj = { literal: "$${VAR}" };
-            const result = substituteEnvVars(obj, getSecret);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                expect(val.literal).toBe("${VAR}");
-            }
-        });
-        it("returns ENV_VAR_ERROR for missing variable", () => {
-            const getSecret = createSecretGetter({});
-            const obj = { missing: "${UNDEFINED_VAR}" };
-            const result = substituteEnvVars(obj, getSecret, "config.yaml");
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("ENV_VAR_ERROR");
-                expect(result.error.message).toContain("UNDEFINED_VAR");
-                expect(result.error.message).toContain("config.yaml");
-            }
-        });
-        it("leaves non-string values untouched (numbers, booleans)", () => {
-            const getSecret = createSecretGetter({});
-            const obj = {
-                count: 42,
-                enabled: true,
-                ratio: 3.14,
-                nothing: null,
-            };
-            const result = substituteEnvVars(obj, getSecret);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                expect(val.count).toBe(42);
-                expect(val.enabled).toBe(true);
-                expect(val.ratio).toBe(3.14);
-                expect(val.nothing).toBe(null);
-            }
-        });
-        it("recursively substitutes nested objects", () => {
-            const getSecret = createSecretGetter({
-                DB_HOST: "db.example.com",
-                DB_PORT: "5432",
-                DB_NAME: "comis",
-            });
-            const obj = {
-                database: {
-                    host: "${DB_HOST}",
-                    port: "${DB_PORT}",
-                    connection: {
-                        name: "${DB_NAME}",
-                    },
-                },
-            };
-            const result = substituteEnvVars(obj, getSecret);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                const db = val.database;
-                expect(db.host).toBe("db.example.com");
-                expect(db.port).toBe("5432");
-                const conn = db.connection;
-                expect(conn.name).toBe("comis");
-            }
-        });
-        it("substitutes string elements in arrays", () => {
-            const getSecret = createSecretGetter({
-                HOST1: "a.example.com",
-                HOST2: "b.example.com",
-            });
-            const obj = {
-                hosts: ["${HOST1}", "${HOST2}", "static.example.com"],
-            };
-            const result = substituteEnvVars(obj, getSecret);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                expect(val.hosts).toEqual([
-                    "a.example.com",
-                    "b.example.com",
-                    "static.example.com",
-                ]);
-            }
-        });
-        it("preserves empty string when VAR resolves to empty string", () => {
-            const getSecret = createSecretGetter({ EMPTY: "" });
-            const obj = { value: "${EMPTY}" };
-            const result = substituteEnvVars(obj, getSecret);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                expect(val.value).toBe("");
-            }
-        });
-        it("does not mutate the input object", () => {
-            const getSecret = createSecretGetter({ VAR: "replaced" });
-            const obj = { key: "${VAR}", nested: { inner: "${VAR}" } };
-            const originalJson = JSON.stringify(obj);
-            substituteEnvVars(obj, getSecret);
-            expect(JSON.stringify(obj)).toBe(originalJson);
-        });
-        it("handles strings with no variable references", () => {
-            const getSecret = createSecretGetter({});
-            const obj = { plain: "no variables here" };
-            const result = substituteEnvVars(obj, getSecret);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                expect(val.plain).toBe("no variables here");
-            }
-        });
-        it("handles mixed escape and substitution in same string", () => {
-            const getSecret = createSecretGetter({ PORT: "3000" });
-            const obj = { mixed: "port=$${PORT_LITERAL} actual=${PORT}" };
-            const result = substituteEnvVars(obj, getSecret);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                expect(val.mixed).toBe("port=${PORT_LITERAL} actual=3000");
-            }
-        });
-        it("auto-corrects bare $VAR_NAME (without braces) when secret exists", () => {
-            const getSecret = createSecretGetter({ GEMINI_API_KEY: "AIza-test-key" });
-            const obj = { env: { GEMINI_API_KEY: "$GEMINI_API_KEY" } };
-            const result = substituteEnvVars(obj, getSecret);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                const env = val.env;
-                expect(env.GEMINI_API_KEY).toBe("AIza-test-key");
-            }
-        });
-        it("returns ENV_VAR_ERROR for bare $VAR_NAME when secret is missing", () => {
-            const getSecret = createSecretGetter({});
-            const obj = { key: "$MISSING_KEY" };
-            const result = substituteEnvVars(obj, getSecret, "config.yaml");
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("ENV_VAR_ERROR");
-                expect(result.error.message).toContain("MISSING_KEY");
-                expect(result.error.message).toContain("auto-corrected");
-            }
-        });
-        it("does NOT auto-correct bare $VAR in mixed-content strings", () => {
-            const getSecret = createSecretGetter({ HOME: "/usr/home" });
-            // "$HOME/path" should NOT be treated as a bare var ref (it has trailing content)
-            const obj = { path: "$HOME/path" };
-            const result = substituteEnvVars(obj, getSecret);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const val = result.value;
-                // Should pass through unchanged (no ${} braces, not a whole-string match)
-                expect(val.path).toBe("$HOME/path");
-            }
-        });
-    });
-    describe("warnSuspiciousEnvValues", () => {
-        it("warns about bare $VAR in env records", () => {
-            const config = {
-                servers: [
-                    {
-                        name: "test",
-                        env: { API_KEY: "$MY_API_KEY" },
-                    },
-                ],
-            };
-            const warnings = warnSuspiciousEnvValues(config, "integrations.mcp");
-            expect(warnings).toHaveLength(1);
-            expect(warnings[0].path).toContain("env.API_KEY");
-            expect(warnings[0].hint).toContain("bare $VAR");
-        });
-        it("warns about [REDACTED] literal in env records", () => {
-            const config = {
-                servers: [
-                    {
-                        name: "test",
-                        env: { API_KEY: "[REDACTED]" },
-                    },
-                ],
-            };
-            const warnings = warnSuspiciousEnvValues(config, "integrations.mcp");
-            expect(warnings).toHaveLength(1);
-            expect(warnings[0].hint).toContain("placeholder");
-        });
-        it("warns about raw API keys in env records", () => {
-            const config = {
-                servers: [{ name: "test", env: { KEY: "sk-abc123" } }],
-            };
-            const warnings = warnSuspiciousEnvValues(config, "integrations.mcp");
-            expect(warnings).toHaveLength(1);
-            expect(warnings[0].hint).toContain("raw API key");
-        });
-        it("does NOT warn about proper ${VAR} references", () => {
-            const config = {
-                servers: [
-                    {
-                        name: "test",
-                        env: { API_KEY: "${MY_API_KEY}" },
-                    },
-                ],
-            };
-            const warnings = warnSuspiciousEnvValues(config, "integrations.mcp");
-            expect(warnings).toHaveLength(0);
-        });
-        it("does NOT warn about non-env string fields", () => {
-            const config = {
-                servers: [{ name: "$not-an-env-ref", command: "npx" }],
-            };
-            const warnings = warnSuspiciousEnvValues(config, "integrations.mcp");
-            expect(warnings).toHaveLength(0);
-        });
-    });
-});

package/node_modules/@comis/core/dist/config/field-metadata.test.d.ts

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

package/node_modules/@comis/core/dist/config/field-metadata.test.js

@@ -1,72 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { getFieldMetadata } from "./field-metadata.js";
-describe("config/field-metadata", () => {
-    describe("getFieldMetadata", () => {
-        it("returns metadata for all top-level config sections", () => {
-            const metadata = getFieldMetadata();
-            expect(metadata.length).toBeGreaterThan(0);
-            // Should contain metadata entries for known top-level keys
-            const paths = metadata.map((m) => m.path);
-            // Top-level scalars
-            expect(paths).toContain("tenantId");
-            expect(paths).toContain("logLevel");
-            expect(paths).toContain("dataDir");
-        });
-        it("each metadata entry has path, type, and immutable flag", () => {
-            const metadata = getFieldMetadata();
-            for (const entry of metadata) {
-                expect(typeof entry.path).toBe("string");
-                expect(entry.path.length).toBeGreaterThan(0);
-                expect(typeof entry.type).toBe("string");
-                expect(typeof entry.immutable).toBe("boolean");
-            }
-        });
-        it("nested fields include dot-notation paths", () => {
-            const metadata = getFieldMetadata("gateway");
-            const paths = metadata.map((m) => m.path);
-            // Gateway has a tls section with nested fields
-            const nestedPaths = paths.filter((p) => p.includes("."));
-            expect(nestedPaths.length).toBeGreaterThan(0);
-        });
-        it("immutable fields are correctly classified (security.* -> immutable: true)", () => {
-            const metadata = getFieldMetadata("security");
-            // All security fields should be immutable
-            for (const entry of metadata) {
-                expect(entry.immutable).toBe(true);
-            }
-        });
-        it("mutable fields are classified (monitoring.* -> immutable: false)", () => {
-            const metadata = getFieldMetadata("monitoring");
-            // Monitoring fields should not be immutable
-            for (const entry of metadata) {
-                expect(entry.immutable).toBe(false);
-            }
-        });
-        it("section filter returns only metadata for specified section", () => {
-            const allMetadata = getFieldMetadata();
-            const gatewayMetadata = getFieldMetadata("gateway");
-            // Filtered result should be smaller than full result
-            expect(gatewayMetadata.length).toBeLessThan(allMetadata.length);
-            // All paths in filtered result should start with "gateway."
-            for (const entry of gatewayMetadata) {
-                expect(entry.path.startsWith("gateway.")).toBe(true);
-            }
-        });
-        it("description field populated from Zod schema descriptions", () => {
-            const metadata = getFieldMetadata();
-            // At least some entries should have descriptions (from JSDoc .describe() on schemas)
-            // tenantId has a description in the schema
-            const tenantId = metadata.find((m) => m.path === "tenantId");
-            expect(tenantId).toBeDefined();
-            // Description may or may not be set depending on schema .describe() usage
-            // But the field should exist on the object
-            expect("description" in tenantId).toBe(true);
-        });
-        it("returns a sorted array", () => {
-            const metadata = getFieldMetadata();
-            const paths = metadata.map((m) => m.path);
-            const sorted = [...paths].sort();
-            expect(paths).toEqual(sorted);
-        });
-    });
-});

package/node_modules/@comis/core/dist/config/git-manager.test.d.ts

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