akm-cli 0.7.0 → 0.7.1

package/dist/tests/info-command.test.js

@@ -1,166 +0,0 @@
-import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { assembleInfo } from "../src/commands/info";
-import { loadConfig, saveConfig } from "../src/core/config";
-import { closeDatabase, openDatabase, rebuildFts, setMeta, upsertEntry } from "../src/indexer/db";
-// ── Temp directory management ───────────────────────────────────────────────
-const createdTmpDirs = [];
-function tmpDir(label = "info") {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), `akm-${label}-`));
-    createdTmpDirs.push(dir);
-    return dir;
-}
-afterAll(() => {
-    for (const dir of createdTmpDirs) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-// ── Environment isolation ───────────────────────────────────────────────────
-const savedEnv = {};
-beforeEach(() => {
-    savedEnv.XDG_CACHE_HOME = process.env.XDG_CACHE_HOME;
-    savedEnv.XDG_CONFIG_HOME = process.env.XDG_CONFIG_HOME;
-    savedEnv.AKM_STASH_DIR = process.env.AKM_STASH_DIR;
-    process.env.XDG_CACHE_HOME = tmpDir("cache");
-    process.env.XDG_CONFIG_HOME = tmpDir("config");
-});
-afterEach(() => {
-    for (const [key, val] of Object.entries(savedEnv)) {
-        if (val === undefined) {
-            delete process.env[key];
-        }
-        else {
-            process.env[key] = val;
-        }
-    }
-});
-// ── Helpers ─────────────────────────────────────────────────────────────────
-function makeStashDir() {
-    const dir = tmpDir("stash");
-    // Create minimal stash structure
-    fs.mkdirSync(path.join(dir, "skills"), { recursive: true });
-    return dir;
-}
-function makeEntry(type, name) {
-    return {
-        type,
-        name,
-        description: `A test ${type}`,
-        tags: ["test"],
-    };
-}
-// ── Tests ───────────────────────────────────────────────────────────────────
-describe("assembleInfo", () => {
-    test("returns a version string", () => {
-        const stashDir = makeStashDir();
-        process.env.AKM_STASH_DIR = stashDir;
-        const info = assembleInfo();
-        expect(typeof info.version).toBe("string");
-        expect(info.version.length).toBeGreaterThan(0);
-    });
-    test("returns assetTypes array with built-in types", () => {
-        const stashDir = makeStashDir();
-        process.env.AKM_STASH_DIR = stashDir;
-        const info = assembleInfo();
-        expect(Array.isArray(info.assetTypes)).toBe(true);
-        expect(info.assetTypes).toContain("skill");
-        expect(info.assetTypes).toContain("command");
-        expect(info.assetTypes).toContain("agent");
-        expect(info.assetTypes).toContain("knowledge");
-        expect(info.assetTypes).toContain("script");
-        expect(info.assetTypes).toContain("memory");
-    });
-    test("returns searchModes array", () => {
-        const stashDir = makeStashDir();
-        process.env.AKM_STASH_DIR = stashDir;
-        const info = assembleInfo();
-        expect(Array.isArray(info.searchModes)).toBe(true);
-        // fts is always available
-        expect(info.searchModes).toContain("fts");
-    });
-    test("works without an index (entryCount: 0)", () => {
-        const stashDir = makeStashDir();
-        process.env.AKM_STASH_DIR = stashDir;
-        const info = assembleInfo();
-        expect(info.indexStats.entryCount).toBe(0);
-        expect(info.indexStats.hasEmbeddings).toBe(false);
-    });
-    test("returns registries from config", () => {
-        const stashDir = makeStashDir();
-        process.env.AKM_STASH_DIR = stashDir;
-        const info = assembleInfo();
-        expect(Array.isArray(info.registries)).toBe(true);
-        // Default config has registries
-        const config = loadConfig();
-        const expected = config.registries ?? [];
-        expect(info.registries.length).toBe(expected.length);
-    });
-    test("includes indexStats when index exists with entries", () => {
-        const stashDir = makeStashDir();
-        process.env.AKM_STASH_DIR = stashDir;
-        // Create an index with some entries
-        const dbPath = path.join(tmpDir("db"), "test.db");
-        const db = openDatabase(dbPath);
-        const entry = makeEntry("skill", "test-skill");
-        upsertEntry(db, "skill:test-skill", "/fake/skill", "/fake/skill/test-skill", stashDir, entry, "test skill");
-        rebuildFts(db);
-        setMeta(db, "builtAt", "2026-03-17T00:00:00Z");
-        closeDatabase(db);
-        const info = assembleInfo({ dbPath });
-        expect(info.indexStats.entryCount).toBe(1);
-        expect(info.indexStats.lastBuiltAt).toBe("2026-03-17T00:00:00Z");
-        expect(typeof info.indexStats.vecAvailable).toBe("boolean");
-    });
-    test("returns sourceProviders from config", () => {
-        const stashDir = makeStashDir();
-        process.env.AKM_STASH_DIR = stashDir;
-        const info = assembleInfo();
-        expect(Array.isArray(info.sourceProviders)).toBe(true);
-    });
-    test("output is valid JSON-serializable", () => {
-        const stashDir = makeStashDir();
-        process.env.AKM_STASH_DIR = stashDir;
-        const info = assembleInfo();
-        const json = JSON.stringify(info);
-        const parsed = JSON.parse(json);
-        expect(parsed.version).toBe(info.version);
-        expect(parsed.assetTypes).toEqual(info.assetTypes);
-        expect(parsed.searchModes).toEqual(info.searchModes);
-        expect(parsed.indexStats).toEqual(info.indexStats);
-    });
-    test("reports pending semantic search status by default", () => {
-        const stashDir = makeStashDir();
-        process.env.AKM_STASH_DIR = stashDir;
-        const info = assembleInfo();
-        expect(info.searchModes).toContain("fts");
-        expect(info.searchModes).not.toContain("semantic");
-        expect(info.searchModes).not.toContain("hybrid");
-        expect(info.semanticSearch.mode).toBe("auto");
-        expect(info.semanticSearch.status).toBe("pending");
-    });
-    test("does not leak apiKey from registry options", () => {
-        const stashDir = makeStashDir();
-        process.env.AKM_STASH_DIR = stashDir;
-        // Write a config with a registry that has an apiKey in its options
-        const config = loadConfig();
-        config.registries = [
-            {
-                url: "https://example.com/registry",
-                name: "test-registry",
-                provider: "static-index",
-                options: { apiKey: "super-secret-key-12345" },
-            },
-        ];
-        saveConfig(config);
-        const info = assembleInfo();
-        expect(info.registries).toHaveLength(1);
-        expect(info.registries[0].url).toBe("https://example.com/registry");
-        expect(info.registries[0].name).toBe("test-registry");
-        // Ensure apiKey is not present anywhere in the serialized output
-        const serialized = JSON.stringify(info);
-        expect(serialized).not.toContain("super-secret-key-12345");
-        expect(serialized).not.toContain("apiKey");
-    });
-});

package/dist/tests/init.test.js

@@ -1,69 +0,0 @@
-/**
- * Tests for `akm init` (#284 GAP-HIGH 12).
- *
- * Verifies that `akmInit` materialises every registered asset-type directory
- * on disk, including the `lessons/` directory required by the proposal queue.
- * Adds a simple regression guard so a future TYPE_DIRS rename doesn't quietly
- * drop the lessons folder from the bootstrap.
- */
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { akmInit } from "../src/commands/init";
-const tempDirs = [];
-const savedEnv = {
-    XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,
-    XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
-    HOME: process.env.HOME,
-};
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-beforeEach(() => {
-    process.env.XDG_CACHE_HOME = makeTempDir("akm-init-cache-");
-    process.env.XDG_CONFIG_HOME = makeTempDir("akm-init-config-");
-    process.env.HOME = makeTempDir("akm-init-home-");
-});
-afterEach(() => {
-    if (savedEnv.XDG_CACHE_HOME === undefined)
-        delete process.env.XDG_CACHE_HOME;
-    else
-        process.env.XDG_CACHE_HOME = savedEnv.XDG_CACHE_HOME;
-    if (savedEnv.XDG_CONFIG_HOME === undefined)
-        delete process.env.XDG_CONFIG_HOME;
-    else
-        process.env.XDG_CONFIG_HOME = savedEnv.XDG_CONFIG_HOME;
-    if (savedEnv.HOME === undefined)
-        delete process.env.HOME;
-    else
-        process.env.HOME = savedEnv.HOME;
-    for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-describe("akm init", () => {
-    test("creates the lessons/ directory on disk under the stash root", async () => {
-        const stashDir = makeTempDir("akm-init-stash-");
-        // Remove dir so init reports created=true
-        fs.rmSync(stashDir, { recursive: true, force: true });
-        const result = await akmInit({ dir: stashDir });
-        expect(result.stashDir).toBe(stashDir);
-        expect(result.created).toBe(true);
-        expect(fs.existsSync(path.join(stashDir, "lessons"))).toBe(true);
-        // Also verify other core type dirs exist (fingerprint of TYPE_DIRS sweep).
-        expect(fs.existsSync(path.join(stashDir, "skills"))).toBe(true);
-        expect(fs.existsSync(path.join(stashDir, "memories"))).toBe(true);
-    });
-    test("re-running on an existing stash is idempotent and keeps lessons/", async () => {
-        const stashDir = makeTempDir("akm-init-stash-2-");
-        await akmInit({ dir: stashDir });
-        // Drop the lessons dir to confirm a re-run rebuilds it.
-        fs.rmSync(path.join(stashDir, "lessons"), { recursive: true, force: true });
-        expect(fs.existsSync(path.join(stashDir, "lessons"))).toBe(false);
-        await akmInit({ dir: stashDir });
-        expect(fs.existsSync(path.join(stashDir, "lessons"))).toBe(true);
-    });
-});

package/dist/tests/install-script.test.js

@@ -1,246 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-const PROJECT_ROOT = path.resolve(import.meta.dirname, "..");
-const INSTALL_SCRIPT = path.join(PROJECT_ROOT, "install.sh");
-const BASH_PATH = resolveCommand("bash");
-const CHMOD_PATH = resolveCommand("chmod");
-const tempRoots = [];
-function resolveCommand(name) {
-    const result = spawnSync("bash", ["-lc", `command -v ${name}`], { encoding: "utf8" });
-    if (result.status !== 0) {
-        throw new Error(`Unable to resolve command: ${name}`);
-    }
-    return result.stdout.trim();
-}
-function writeExecutable(filePath, content) {
-    fs.writeFileSync(filePath, content, { mode: 0o755 });
-}
-function addProxy(fakeBin, name) {
-    const real = resolveCommand(name);
-    writeExecutable(`${fakeBin}/${name}`, `#!${BASH_PATH}\nexec ${real} "$@"\n`);
-}
-function createHarness(options = {}) {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "akm-install-test-"));
-    tempRoots.push(root);
-    const fakeBin = path.join(root, "fakebin");
-    const installDir = path.join(root, options.installDirName ?? "install-dir");
-    const logFile = path.join(root, "requests.log");
-    fs.mkdirSync(fakeBin, { recursive: true });
-    fs.mkdirSync(installDir, { recursive: true });
-    addProxy(fakeBin, "mktemp");
-    addProxy(fakeBin, "awk");
-    addProxy(fakeBin, "chmod");
-    addProxy(fakeBin, "mv");
-    addProxy(fakeBin, "rm");
-    const checksumTool = options.checksumTool ?? "sha256sum";
-    if (checksumTool === "sha256sum") {
-        addProxy(fakeBin, "sha256sum");
-    }
-    if (checksumTool === "shasum") {
-        addProxy(fakeBin, "shasum");
-    }
-    const osName = options.osName ?? "Linux";
-    const archName = options.archName ?? "x86_64";
-    writeExecutable(path.join(fakeBin, "uname"), `#!${BASH_PATH}
-if [ "\${1:-}" = "-s" ]; then
-  printf '%s\n' '${osName}'
-elif [ "\${1:-}" = "-m" ]; then
-  printf '%s\n' '${archName}'
-else
-  printf '%s\n' '${osName}'
-fi
-`);
-    const downloader = options.downloader ?? "curl";
-    const binaryName = `akm-${osName === "Darwin" ? "darwin" : osName === "Linux" ? "linux" : "windows"}-${archName === "x86_64" ? "x64" : archName}`;
-    const binaryContent = "fake-akm-binary";
-    const binaryHash = createHash("sha256").update(binaryContent).digest("hex");
-    const checksumMode = options.checksumMode ?? "match";
-    const downloadScript = `#!${BASH_PATH}
-set -euo pipefail
-outfile=""
-url=""
-while [ "$#" -gt 0 ]; do
-  case "$1" in
-    -o)
-      outfile="$2"
-      shift 2
-      ;;
-    -qO)
-      outfile="$2"
-      shift 2
-      ;;
-    -fsSL|-q)
-      shift
-      ;;
-    *)
-      url="$1"
-      shift
-      ;;
-  esac
-done
-printf '%s\n' "$url" >> "${logFile}"
-if [[ "$url" == *checksums.txt ]]; then
-  case "${checksumMode}" in
-    match)
-      printf '%s  %s\n' '${binaryHash}' '${binaryName}' > "$outfile"
-      ;;
-    mismatch)
-      printf '%s  %s\n' 'deadbeef' '${binaryName}' > "$outfile"
-      ;;
-    missing)
-      printf '%s  %s\n' '${binaryHash}' 'other-binary' > "$outfile"
-      ;;
-  esac
-else
-  printf '%s' '${binaryContent}' > "$outfile"
-fi
-`;
-    if (downloader === "curl") {
-        writeExecutable(path.join(fakeBin, "curl"), downloadScript);
-    }
-    if (downloader === "wget") {
-        writeExecutable(path.join(fakeBin, "wget"), downloadScript);
-    }
-    if (options.useSudo) {
-        writeExecutable(path.join(fakeBin, "sudo"), `#!${BASH_PATH}
-set -euo pipefail
-printf 'sudo %s\n' "$*" >> "${logFile}"
-if [ "${options.sudoSucceeds === false ? "0" : "1"}" = "0" ]; then
-  exit 127
-fi
-if [ "$1" = "mv" ]; then
-  dest="${installDir}"
-  ${CHMOD_PATH} u+w "$dest"
-fi
-exec "$@"
-`);
-    }
-    if (downloader === "none") {
-        // Intentionally do not create curl/wget so command -v fails.
-    }
-    if (options.installDirWritable === false) {
-        fs.chmodSync(installDir, 0o555);
-    }
-    return {
-        root,
-        installDir,
-        logFile,
-        binaryName,
-        run: (args = []) => spawnSync(BASH_PATH, [INSTALL_SCRIPT, ...args], {
-            cwd: PROJECT_ROOT,
-            encoding: "utf8",
-            env: {
-                ...process.env,
-                PATH: downloader === "none" ? buildPathWithoutDownloaders(fakeBin) : fakeBin,
-                AKM_INSTALL_DIR: installDir,
-            },
-        }),
-    };
-}
-function buildPathWithoutDownloaders(fakeBin) {
-    const segments = (process.env.PATH ?? "").split(":").filter(Boolean);
-    const filtered = segments.filter((segment) => {
-        for (const name of ["curl", "wget"]) {
-            const candidate = path.join(segment, name);
-            if (fs.existsSync(candidate)) {
-                return false;
-            }
-        }
-        return true;
-    });
-    return [fakeBin, ...filtered].join(":");
-}
-afterEach(() => {
-    while (tempRoots.length > 0) {
-        const root = tempRoots.pop();
-        if (root) {
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    }
-});
-describe("install.sh", () => {
-    test("installs the latest linux x64 binary with curl into a custom dir", () => {
-        const harness = createHarness();
-        const result = harness.run();
-        expect(result.status).toBe(0);
-        expect(fs.existsSync(path.join(harness.installDir, "akm"))).toBe(true);
-        expect(result.stdout).toContain(`akm installed to ${harness.installDir}/akm`);
-        const log = fs.readFileSync(harness.logFile, "utf8");
-        expect(log).toContain(`/releases/latest/download/${harness.binaryName}`);
-        expect(log).toContain("/releases/latest/download/checksums.txt");
-    });
-    test("uses wget fallback and pinned tags when curl is unavailable", () => {
-        const harness = createHarness({ downloader: "wget" });
-        const result = harness.run(["v1.2.3"]);
-        expect(result.status).toBe(0);
-        const log = fs.readFileSync(harness.logFile, "utf8");
-        expect(log).toContain(`/releases/download/v1.2.3/${harness.binaryName}`);
-        expect(log).toContain("/releases/download/v1.2.3/checksums.txt");
-    });
-    test("fails clearly when checksum entry is missing", () => {
-        const harness = createHarness({ checksumMode: "missing" });
-        const result = harness.run();
-        expect(result.status).not.toBe(0);
-        expect(result.stderr).toContain(`checksum not found for ${harness.binaryName}`);
-    });
-    test("fails clearly on checksum mismatch", () => {
-        const harness = createHarness({ checksumMode: "mismatch" });
-        const result = harness.run();
-        expect(result.status).not.toBe(0);
-        expect(result.stderr).toContain(`checksum verification failed for ${harness.binaryName}`);
-    });
-    test("fails when no downloader is available", () => {
-        const harness = createHarness({ downloader: "none" });
-        const result = harness.run();
-        expect(result.status).not.toBe(0);
-        expect(result.stdout + result.stderr).toContain("curl or wget is required");
-    });
-    test("uses sudo mv when install dir is not writable", () => {
-        const harness = createHarness({ installDirWritable: false, useSudo: true });
-        const result = harness.run();
-        expect(result.status).toBe(0);
-        const log = fs.readFileSync(harness.logFile, "utf8");
-        expect(log).toContain("sudo mv");
-        expect(fs.existsSync(path.join(harness.installDir, "akm"))).toBe(true);
-    });
-    test("falls back to shasum when sha256sum is unavailable", () => {
-        const harness = createHarness({ checksumTool: "shasum" });
-        const result = harness.run();
-        expect(result.status).toBe(0);
-        expect(fs.existsSync(path.join(harness.installDir, "akm"))).toBe(true);
-    });
-    test("fails when no checksum tool is available", () => {
-        const harness = createHarness({ checksumTool: "none" });
-        const result = harness.run();
-        expect(result.status).not.toBe(0);
-        expect(result.stdout + result.stderr).toContain("sha256sum or shasum is required");
-    });
-    test("fails clearly on unsupported architecture", () => {
-        const harness = createHarness({ archName: "riscv64" });
-        const result = harness.run();
-        expect(result.status).not.toBe(0);
-        expect(result.stderr).toContain("Unsupported architecture");
-    });
-    test("installs successfully when install dir contains spaces", () => {
-        const harness = createHarness({ installDirName: "install dir with spaces" });
-        const result = harness.run();
-        expect(result.status).toBe(0);
-        expect(fs.existsSync(path.join(harness.installDir, "akm"))).toBe(true);
-    });
-    test("fails clearly when sudo is required but unavailable", () => {
-        const harness = createHarness({ installDirWritable: false, useSudo: true, sudoSucceeds: false });
-        const result = harness.run();
-        expect(result.status).not.toBe(0);
-        expect(fs.existsSync(path.join(harness.installDir, "akm"))).toBe(false);
-    });
-    test("prints the Windows install.ps1 guidance on MINGW", () => {
-        const harness = createHarness({ osName: "MINGW64_NT" });
-        const result = harness.run();
-        expect(result.status).toBe(1);
-        expect(result.stderr).toContain("install.ps1");
-    });
-});

package/dist/tests/integration/agent-real-profile.test.js

@@ -1,94 +0,0 @@
-/**
- * Opt-in real-profile integration tests for `akm reflect` and `akm propose` (#226).
- *
- * Skipped by default in CI. Enable by exporting `AKM_REAL_AGENT_TESTS=1`
- * (and a credential for the chosen profile, e.g. `OPENCODE_API_KEY` or
- * `ANTHROPIC_API_KEY`). Each test spawns the actual agent CLI through the
- * documented profile and checks that a proposal lands in the queue.
- *
- * The prompts here are intentionally cheap — single short asset, no long
- * context — to keep cost minimal when developers run them locally.
- */
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { akmPropose } from "../../src/commands/propose";
-import { akmReflect } from "../../src/commands/reflect";
-import { listProposals } from "../../src/core/proposals";
-import { getBuiltinAgentProfile } from "../../src/integrations/agent/profiles";
-const REAL_AGENT_TESTS = process.env.AKM_REAL_AGENT_TESTS === "1" || process.env.AKM_REAL_AGENT_TESTS === "true";
-const tempDirs = [];
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-function makeStashDir() {
-    const stash = makeTempDir("akm-real-agent-stash-");
-    for (const dir of ["lessons", "skills"]) {
-        fs.mkdirSync(path.join(stash, dir), { recursive: true });
-    }
-    return stash;
-}
-describe.skipIf(!REAL_AGENT_TESTS)("real-profile integration (opt-in via AKM_REAL_AGENT_TESTS)", () => {
-    let priorXdgCacheHome;
-    let priorXdgConfigHome;
-    beforeAll(() => {
-        priorXdgCacheHome = process.env.XDG_CACHE_HOME;
-        priorXdgConfigHome = process.env.XDG_CONFIG_HOME;
-        process.env.XDG_CACHE_HOME = makeTempDir("akm-real-agent-cache-");
-        process.env.XDG_CONFIG_HOME = makeTempDir("akm-real-agent-config-");
-    });
-    afterAll(() => {
-        if (priorXdgCacheHome === undefined)
-            delete process.env.XDG_CACHE_HOME;
-        else
-            process.env.XDG_CACHE_HOME = priorXdgCacheHome;
-        if (priorXdgConfigHome === undefined)
-            delete process.env.XDG_CONFIG_HOME;
-        else
-            process.env.XDG_CONFIG_HOME = priorXdgConfigHome;
-        for (const dir of tempDirs.splice(0)) {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    test("opencode profile produces a queued proposal via akm propose", async () => {
-        const profile = getBuiltinAgentProfile("opencode");
-        expect(profile).toBeDefined();
-        if (!profile)
-            return;
-        const stash = makeStashDir();
-        const result = await akmPropose({
-            type: "skill",
-            name: "real-profile-hello",
-            task: "Author a one-line skill that says hello.",
-            stashDir: stash,
-            agentProfile: { ...profile, stdio: "captured" },
-            timeoutMs: 60_000,
-        });
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            throw new Error(`propose failed: ${result.reason}: ${result.error}`);
-        const proposals = listProposals(stash);
-        expect(proposals.length).toBeGreaterThanOrEqual(1);
-    });
-    test("claude profile produces a queued proposal via akm reflect", async () => {
-        const profile = getBuiltinAgentProfile("claude");
-        expect(profile).toBeDefined();
-        if (!profile)
-            return;
-        const stash = makeStashDir();
-        const result = await akmReflect({
-            ref: "lesson:real-profile-tip",
-            stashDir: stash,
-            agentProfile: { ...profile, stdio: "captured" },
-            timeoutMs: 60_000,
-        });
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            throw new Error(`reflect failed: ${result.reason}: ${result.error}`);
-        const proposals = listProposals(stash);
-        expect(proposals.length).toBeGreaterThanOrEqual(1);
-    });
-});