bet-cli 0.1.1 → 0.1.3

package/README.md

@@ -1,3 +1,13 @@
+```
+  ██
+  ██
+  ████████████
+             ██
+             ████████
+                    ╲╲
+                   ╲╲
+```
+
 # bet
 
 Keep your house in order. Explore and jump between local projects.
@@ -77,12 +87,21 @@ After that:
 - `bet go <slug>` will `cd` your current shell into the project
 - `bet list` / `bet search` can also “select and jump” in interactive mode
 
+**Project name autocompletion:** To complete project names (slugs) when using `bet go`, `bet path`, or `bet info`, add to your rc file:
+
+```sh
+eval "$(bet completion zsh)"   # zsh
+eval "$(bet completion bash)"  # bash
+```
+
+Then Tab-complete the slug argument after `bet go `, `bet path `, or `bet info `.
+
 ## Core commands
 
 - **`bet update`**: Scan configured roots and rebuild the project index.
   - **First-time setup**: `bet update --roots "$HOME/code,$HOME/work"`
   - If you pass `--roots` when you already have roots in config, you will be warned and must confirm (or use `--force` when not in a TTY).
-  - **Optional**: `--cron` installs an hourly `crontab` entry that runs `bet update` and logs output to your bet config directory
+  - **Optional**: `--cron [frequency]` — install a `crontab` entry that runs `bet update` on a schedule. Use Nm (1–59), Nh (1–24), or Nd (1–31), e.g. `--cron 5m`, `--cron 1h` (default if omitted), `--cron 2d`. Use `--cron 0` or `--cron false` to remove the cron. Cron stdout/stderr are appended to `~/.config/bet/cron-update.log`; structured logs go to the main log file (see [Logging](#logging)).
 - **`bet list`**: List indexed projects (interactive by default).
   - **`--plain`**: non-interactive output
   - **`--json`**: machine-readable output
@@ -94,6 +113,7 @@ After that:
   - **`--print`**: print selected path only (no shell `cd`)
   - **`--no-enter`**: do not run the project’s `onEnter` hook (if configured)
 - **`bet shell`**: Print the shell integration snippet (see above).
+- **`bet completion [bash|zsh]`**: Print shell completion script for project name autocompletion (see above).
 
 ## Config & data files
 
@@ -101,10 +121,20 @@ bet stores its data in:
 
 - **Config dir**: `~/.config/bet/` (or `$XDG_CONFIG_HOME/bet/`)
 - **Roots**: `config.json` — each root is `{ "path": "/absolute/path", "name": "display-name" }`. The name defaults to the top folder name and is used when listing/grouping projects.
+- **slugParentFolders** (optional): In `config.json`, an array of folder names. When a discovered project path ends in one of these (e.g. `src` or `app`), the project slug is taken from the parent directory name instead. Default in code is `["src", "app"]` when the key is not set.
 - **Project index**: `projects.json`
 
 These are plain JSON files—easy to inspect, back up, or edit.
 
+### Logging
+
+bet writes a structured log file for debugging, especially when `bet update` runs from cron:
+
+- **macOS**: `~/Library/Logs/bet/bet.log`
+- **Linux**: `~/.local/state/bet/bet.log` (or `$XDG_STATE_HOME/bet/bet.log`)
+
+Each line is timestamped and includes a level (`DEBUG`, `INFO`, `WARN`, `ERROR`). Set `BET_LOG_LEVEL=debug` for verbose output when troubleshooting (e.g. in your cron environment). When run from cron, stdout/stderr are also captured in `~/.config/bet/cron-update.log`; the main log file is the structured, level-based log.
+
 ### Advanced filtering with `--json`
 
 You can combine `bet list --json` with [jq](https://stedolan.github.io/jq/) for powerful, scriptable project filtering. Here are some practical examples:

package/dist/commands/completion.js

@@ -0,0 +1,110 @@
+import { getProjectSlugs } from "../lib/completion.js";
+const SLUG_COMMANDS = ["go", "path", "info"];
+const SUBCOMMANDS = [
+    "update",
+    "list",
+    "search",
+    "info",
+    "go",
+    "path",
+    "shell",
+    "completion",
+    "ignore",
+];
+function zshScript() {
+    const slugCommandsPattern = SLUG_COMMANDS.join("|");
+    return `#compdef bet
+_bet() {
+  local -a subcommands
+  subcommands=(
+    'update:Scan roots and rebuild project index'
+    'list:List projects'
+    'search:Fuzzy-search projects'
+    'info:Show project details'
+    'go:Jump to a project'
+    'path:Print project path'
+    'shell:Print shell integration'
+    'completion:Print shell completion script'
+    'ignore:Manage ignored project paths'
+  )
+
+  if (( CURRENT == 2 )); then
+    _describe 'bet commands' subcommands
+    return
+  fi
+
+  if [[ "${slugCommandsPattern}" == *"\$words[2]"* ]]; then
+    if (( CURRENT == 3 )); then
+      local -a slugs
+      slugs=(\$(command bet completion --list 2>/dev/null))
+      _describe 'project' slugs
+    fi
+    return
+  fi
+
+  _default
+}
+compdef _bet bet
+`;
+}
+function bashScript() {
+    const subcommandsList = SUBCOMMANDS.join(" ");
+    const cw = "COMP_WORDS";
+    const cc = "COMP_CWORD";
+    const dollar = "$";
+    return `_bet_completions() {
+  local cur="${dollar}{${cw}[${cc}]}"
+
+  if (( ${cc} == 1 )); then
+    COMPREPLY=(\$(compgen -W "${subcommandsList}" -- "${dollar}cur"))
+    return
+  fi
+
+  local cmd="${dollar}{${cw}[1]}"
+  if [[ "${dollar}cmd" == "go" || "${dollar}cmd" == "path" || "${dollar}cmd" == "info" ]]; then
+    if (( ${cc} == 2 )); then
+      local slugs
+      slugs=\$(command bet completion --list 2>/dev/null)
+      COMPREPLY=(\$(compgen -W "${dollar}slugs" -- "${dollar}cur"))
+    fi
+  fi
+}
+complete -F _bet_completions bet
+`;
+}
+export function registerCompletion(program) {
+    program
+        .command("completion [shell]")
+        .description("Print shell completion script for project name autocompletion")
+        .option("--list", "Print project slugs only (for use by completion script)")
+        .option("--prefix <prefix>", "Filter slugs by prefix")
+        .action(async (shell, options) => {
+        if (options.list) {
+            let slugs = await getProjectSlugs();
+            if (options.prefix?.length) {
+                const p = options.prefix.toLowerCase();
+                slugs = slugs.filter((s) => s.toLowerCase().startsWith(p));
+            }
+            for (const slug of slugs) {
+                process.stdout.write(`${slug}\n`);
+            }
+            return;
+        }
+        const sh = shell?.toLowerCase() ?? "";
+        if (sh === "zsh") {
+            process.stdout.write(zshScript());
+            return;
+        }
+        if (sh === "bash") {
+            process.stdout.write(bashScript());
+            return;
+        }
+        if (shell !== undefined) {
+            process.stderr.write(`Unknown shell "${shell}". Use bash or zsh.\n`);
+            process.exitCode = 1;
+            return;
+        }
+        process.stderr.write("Usage: bet completion [bash|zsh]\n  eval \"$(bet completion zsh)\"\n");
+        process.exitCode = 1;
+    });
+}

package/dist/commands/ignore.js

@@ -0,0 +1,78 @@
+import { readConfig, writeConfig } from "../lib/config.js";
+import { normalizeAbsolute, isSubpath } from "../utils/paths.js";
+function isPathUnderRoot(filePath, rootPath) {
+    return filePath === rootPath || isSubpath(filePath, rootPath);
+}
+function isPathUnderAnyRoot(filePath, rootPaths) {
+    return rootPaths.some((rootPath) => isPathUnderRoot(filePath, rootPath));
+}
+export function registerIgnore(program) {
+    const ignoreCmd = program
+        .command("ignore")
+        .description("Manage ignored project paths (excluded from index)");
+    ignoreCmd
+        .command("add [filepath]")
+        .description("Add a path to the ignore list (must be under a configured root)")
+        .option("--this", "Ignore the current folder")
+        .action(async (filepath, options) => {
+        const pathToAdd = options.this ? process.cwd() : filepath;
+        if (pathToAdd === undefined || pathToAdd === "") {
+            process.stderr.write("Error: Provide a path or use --this to ignore the current folder.\n");
+            process.exitCode = 1;
+            return;
+        }
+        const normalized = normalizeAbsolute(pathToAdd);
+        const config = await readConfig();
+        if (!config.roots.length) {
+            process.stderr.write("Error: No roots configured. Add roots first (e.g. bet update --roots /path/to/code).\n");
+            process.exitCode = 1;
+            return;
+        }
+        const rootPaths = config.roots.map((r) => r.path);
+        if (!isPathUnderAnyRoot(normalized, rootPaths)) {
+            process.stderr.write(`Error: Path must be under a configured root.\n  Path: ${normalized}\n  Roots: ${rootPaths.join(", ")}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        const ignoredPaths = config.ignoredPaths ?? [];
+        if (ignoredPaths.includes(normalized)) {
+            process.stdout.write(`Already ignored: ${normalized}\n`);
+            return;
+        }
+        const nextIgnoredPaths = [...ignoredPaths, normalized];
+        await writeConfig({
+            ...config,
+            ignoredPaths: nextIgnoredPaths,
+        });
+        process.stdout.write(`Ignored: ${normalized}\n`);
+    });
+    ignoreCmd
+        .command("rm <filepath>")
+        .description("Remove a path from the ignore list")
+        .action(async (filepath) => {
+        const normalized = normalizeAbsolute(filepath);
+        const config = await readConfig();
+        const ignoredPaths = config.ignoredPaths ?? [];
+        const index = ignoredPaths.indexOf(normalized);
+        if (index === -1) {
+            process.stdout.write(`Not in ignore list: ${normalized}\n`);
+            return;
+        }
+        const nextIgnoredPaths = ignoredPaths.filter((_, i) => i !== index);
+        await writeConfig({
+            ...config,
+            ignoredPaths: nextIgnoredPaths.length > 0 ? nextIgnoredPaths : undefined,
+        });
+        process.stdout.write(`Removed from ignore list: ${normalized}\n`);
+    });
+    ignoreCmd
+        .command("list")
+        .description("List ignored paths")
+        .action(async () => {
+        const config = await readConfig();
+        const ignoredPaths = config.ignoredPaths ?? [];
+        for (const p of ignoredPaths) {
+            process.stdout.write(`${p}\n`);
+        }
+    });
+}

package/dist/commands/update.js

@@ -2,10 +2,12 @@ import path from "node:path";
 import readline from "node:readline";
 import { readConfig, resolveRoots, writeConfig } from "../lib/config.js";
 import { normalizeAbsolute } from "../utils/paths.js";
-import { installHourlyUpdateCron } from "../lib/cron.js";
+import { installUpdateCron, uninstallUpdateCron, parseCronSchedule, formatScheduleLabel } from "../lib/cron.js";
 import { scanRoots } from "../lib/scan.js";
 import { computeMetadata } from "../lib/metadata.js";
+import { getEffectiveIgnores, isPathIgnored } from "../lib/ignore.js";
 import { isInsideGitRepo } from "../lib/git.js";
+import { log } from "../lib/logger.js";
 function parseRoots(value) {
     if (!value)
         return undefined;
@@ -24,9 +26,11 @@ export function willOverrideRoots(providedRootConfigs, configRoots) {
     return !!(providedRootConfigs !== undefined &&
         configRoots.length > 0);
 }
-function projectSlug(pathName) {
+const DEFAULT_SLUG_PARENT_FOLDERS = ["src", "app"];
+export { DEFAULT_SLUG_PARENT_FOLDERS };
+export function projectSlug(pathName, slugParentFolders) {
     const folderName = path.basename(pathName);
-    if (folderName === "src" || folderName === "app") {
+    if (slugParentFolders.includes(folderName)) {
         return path.basename(path.dirname(pathName));
     }
     return folderName;
@@ -52,89 +56,144 @@ export function registerUpdate(program) {
         .description("Scan roots and update the project index")
         .option("--roots <paths>", "Comma-separated list of roots to scan")
         .option("--force", "Allow overriding configured roots when not in TTY")
-        .option("--cron", "Install an hourly cron job to run bet update")
+        .option("--cron [frequency]", "Run update on a schedule: Nm/Nh/Nd e.g. 5m, 1h, 2d (default 1h), or 0/false to disable")
         .action(async (options) => {
-        const config = await readConfig();
-        const providedPaths = parseRoots(options.roots);
-        const providedRootConfigs = providedPaths
-            ? pathsToRootConfigs(providedPaths)
-            : undefined;
-        const configRoots = config.roots.length > 0 ? config.roots : undefined;
-        const rootsToUse = providedRootConfigs ?? configRoots;
-        if (!rootsToUse || rootsToUse.length === 0) {
-            process.stderr.write("Error: No roots specified. Please provide roots using --roots option.\n" +
-                "Example: bet update --roots /path/to/your/code\n");
-            process.exitCode = 1;
-            return;
-        }
-        const willOverride = willOverrideRoots(providedRootConfigs, config.roots);
-        if (willOverride) {
-            process.stderr.write("Warning: --roots will override your configured roots.\n" +
-                "  Configured: " +
-                configRoots.map((r) => r.path).join(", ") +
-                "\n  Provided:   " +
-                providedRootConfigs.map((r) => r.path).join(", ") +
-                "\n");
-            if (!process.stdin.isTTY) {
-                if (!options.force) {
-                    process.stderr.write("Error: Refusing to override without confirmation. Run interactively or use --force.\n");
-                    process.exitCode = 1;
-                    return;
-                }
+        try {
+            const config = await readConfig();
+            const providedPaths = parseRoots(options.roots);
+            const providedRootConfigs = providedPaths
+                ? pathsToRootConfigs(providedPaths)
+                : undefined;
+            const configRoots = config.roots.length > 0 ? config.roots : undefined;
+            const rootsToUse = providedRootConfigs ?? configRoots;
+            if (!rootsToUse || rootsToUse.length === 0) {
+                log.error("update failed: no roots specified");
+                process.stderr.write("Error: No roots specified. Please provide roots using --roots option.\n" +
+                    "Example: bet update --roots /path/to/your/code\n");
+                process.exitCode = 1;
+                return;
             }
-            else {
-                const confirmed = await promptYesNo("Continue?", true);
-                if (!confirmed) {
-                    process.stderr.write("Aborted.\n");
-                    return;
+            const willOverride = willOverrideRoots(providedRootConfigs, config.roots);
+            if (willOverride) {
+                log.warn("--roots overrides configured roots", "configured:", configRoots.map((r) => r.path).join(", "), "provided:", providedRootConfigs.map((r) => r.path).join(", "));
+                process.stderr.write("Warning: --roots will override your configured roots.\n" +
+                    "  Configured: " +
+                    configRoots.map((r) => r.path).join(", ") +
+                    "\n  Provided:   " +
+                    providedRootConfigs.map((r) => r.path).join(", ") +
+                    "\n");
+                if (!process.stdin.isTTY) {
+                    if (!options.force) {
+                        log.error("update failed: refusing to override roots without confirmation (use --force when not in TTY)");
+                        process.stderr.write("Error: Refusing to override without confirmation. Run interactively or use --force.\n");
+                        process.exitCode = 1;
+                        return;
+                    }
+                }
+                else {
+                    const confirmed = await promptYesNo("Continue?", true);
+                    if (!confirmed) {
+                        log.info("update aborted by user");
+                        process.stderr.write("Aborted.\n");
+                        return;
+                    }
                 }
             }
-        }
-        const rootsResolved = resolveRoots(rootsToUse);
-        const rootPaths = rootsResolved.map((r) => r.path);
-        const candidates = await scanRoots(rootPaths);
-        const projects = {};
-        for (const candidate of candidates) {
-            const hasGit = await isInsideGitRepo(candidate.path);
-            const auto = await computeMetadata(candidate.path, hasGit);
-            const slug = projectSlug(candidate.path);
-            const existing = config.projects[candidate.path];
-            const rootConfig = rootsResolved.find((r) => r.path === candidate.root);
-            const rootName = rootConfig?.name ?? path.basename(candidate.root);
-            const project = {
-                id: candidate.path,
-                slug,
-                name: slug,
-                path: candidate.path,
-                root: candidate.root,
-                rootName,
-                hasGit,
-                hasReadme: candidate.hasReadme,
-                auto,
-                user: existing?.user,
+            const rootsResolved = resolveRoots(rootsToUse);
+            const rootPaths = rootsResolved.map((r) => r.path);
+            log.info("update started", "roots=" + rootPaths.join(", "));
+            log.debug("scanning roots", rootPaths.length, "root(s)");
+            const ignores = getEffectiveIgnores(config);
+            const candidates = await scanRoots(rootPaths, ignores);
+            const ignoredPaths = config.ignoredPaths ?? [];
+            const filteredCandidates = candidates.filter((c) => !isPathIgnored(c.path, ignoredPaths));
+            log.debug("found", filteredCandidates.length, "candidate(s) after ignoring paths");
+            const projects = {};
+            for (const candidate of filteredCandidates) {
+                const hasGit = await isInsideGitRepo(candidate.path);
+                const auto = await computeMetadata(candidate.path, hasGit, ignores);
+                const slug = projectSlug(candidate.path, config.slugParentFolders ?? DEFAULT_SLUG_PARENT_FOLDERS);
+                const existing = config.projects[candidate.path];
+                const rootConfig = rootsResolved.find((r) => r.path === candidate.root);
+                const rootName = rootConfig?.name ?? path.basename(candidate.root);
+                const project = {
+                    id: candidate.path,
+                    slug,
+                    name: slug,
+                    path: candidate.path,
+                    root: candidate.root,
+                    rootName,
+                    hasGit,
+                    hasReadme: candidate.hasReadme,
+                    auto,
+                    user: existing?.user,
+                };
+                projects[candidate.path] = project;
+            }
+            const nextConfig = {
+                version: config.version ?? 1,
+                roots: rootsResolved,
+                projects,
+                ...(config.ignores !== undefined && { ignores: config.ignores }),
+                ...(config.ignoredPaths !== undefined && { ignoredPaths: config.ignoredPaths }),
+                ...(config.slugParentFolders !== undefined && { slugParentFolders: config.slugParentFolders }),
             };
-            projects[candidate.path] = project;
+            await writeConfig(nextConfig);
+            const projectCount = Object.keys(projects).length;
+            const rootCount = rootsResolved.length;
+            log.info("update completed", "projects=" + projectCount, "roots=" + rootCount);
+            process.stdout.write("Indexed " +
+                projectCount +
+                " projects from " +
+                rootCount +
+                " root(s).\n");
+            if (options.cron !== undefined && options.cron !== false) {
+                const entryScriptPath = path.isAbsolute(process.argv[1] ?? "")
+                    ? process.argv[1]
+                    : path.resolve(process.cwd(), process.argv[1] ?? "dist/index.js");
+                const cronOpt = options.cron;
+                if (cronOpt === true) {
+                    const { wrapperPath, logPath } = await installUpdateCron({
+                        nodePath: process.execPath,
+                        entryScriptPath,
+                        schedule: "1h",
+                    });
+                    process.stdout.write("Installed cron for bet update (every hour).\n");
+                    process.stdout.write(`  Wrapper script: ${wrapperPath}\n  Log file: ${logPath}\n  To view or edit crontab: crontab -l  /  crontab -e\n`);
+                }
+                else if (typeof cronOpt === "string") {
+                    const normalized = cronOpt.trim().toLowerCase();
+                    if (normalized === "0" || normalized === "false") {
+                        await uninstallUpdateCron();
+                        process.stdout.write("Removed cron for bet update.\n");
+                    }
+                    else {
+                        try {
+                            const parsed = parseCronSchedule(cronOpt);
+                            const { wrapperPath, logPath } = await installUpdateCron({
+                                nodePath: process.execPath,
+                                entryScriptPath,
+                                schedule: cronOpt,
+                            });
+                            const label = formatScheduleLabel(parsed);
+                            process.stdout.write(`Installed cron for bet update (${label}).\n`);
+                            process.stdout.write(`  Wrapper script: ${wrapperPath}\n  Log file: ${logPath}\n  To view or edit crontab: crontab -l  /  crontab -e\n`);
+                        }
+                        catch (err) {
+                            const message = err instanceof Error ? err.message : String(err);
+                            log.error(err instanceof Error ? err : new Error(message));
+                            process.stderr.write(`Error: ${message}\n`);
+                            process.exitCode = 1;
+                        }
+                    }
+                }
+            }
         }
-        const nextConfig = {
-            version: config.version ?? 1,
-            roots: rootsResolved,
-            projects,
-        };
-        await writeConfig(nextConfig);
-        process.stdout.write("Indexed " +
-            Object.keys(projects).length +
-            " projects from " +
-            rootsResolved.length +
-            " root(s).\n");
-        if (options.cron) {
-            const entryScriptPath = path.isAbsolute(process.argv[1] ?? "")
-                ? process.argv[1]
-                : path.resolve(process.cwd(), process.argv[1] ?? "dist/index.js");
-            await installHourlyUpdateCron({
-                nodePath: process.execPath,
-                entryScriptPath,
-            });
-            process.stdout.write("Installed hourly cron job for bet update.\n");
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log.error(err instanceof Error ? err : new Error(message));
+            process.stderr.write(`Error: ${message}\n`);
+            process.exitCode = 1;
         }
     });
 }

package/dist/index.js

@@ -7,11 +7,13 @@ import { registerInfo } from "./commands/info.js";
 import { registerGo } from "./commands/go.js";
 import { registerPath } from "./commands/path.js";
 import { registerShell } from "./commands/shell.js";
+import { registerCompletion } from "./commands/completion.js";
+import { registerIgnore } from "./commands/ignore.js";
 const program = new Command();
 program
     .name("bet")
     .description("Explore and jump between local projects.")
-    .version("0.1.0");
+    .version("0.1.2");
 registerUpdate(program);
 registerList(program);
 registerSearch(program);
@@ -19,4 +21,6 @@ registerInfo(program);
 registerGo(program);
 registerPath(program);
 registerShell(program);
+registerCompletion(program);
+registerIgnore(program);
 program.parseAsync(process.argv);

package/dist/lib/completion.js

@@ -0,0 +1,16 @@
+import { readConfig } from "./config.js";
+import { listProjects } from "./projects.js";
+/**
+ * Returns project slugs for shell completion. On missing config or error,
+ * returns an empty array so the completion path can exit 0 with no output.
+ */
+export async function getProjectSlugs() {
+    try {
+        const config = await readConfig();
+        const projects = listProjects(config);
+        return projects.map((p) => p.slug);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/lib/config.js

@@ -42,15 +42,39 @@ function normalizeRoots(parsedRoots) {
     }
     return result;
 }
+function normalizeIgnores(parsed) {
+    if (!Array.isArray(parsed))
+        return undefined;
+    const list = parsed.filter((x) => typeof x === "string");
+    return list;
+}
+function normalizeSlugParentFolders(parsed) {
+    if (!Array.isArray(parsed))
+        return undefined;
+    const list = parsed.filter((x) => typeof x === "string" && x.trim() !== "").map((x) => x.trim());
+    return list.length === 0 ? undefined : list;
+}
+function normalizeIgnoredPaths(parsed) {
+    if (!Array.isArray(parsed))
+        return undefined;
+    const list = parsed.filter((x) => typeof x === "string").map((x) => normalizeAbsolute(x));
+    return list.length === 0 ? undefined : list;
+}
 async function readAppConfig() {
     try {
         const raw = await fs.readFile(CONFIG_PATH, "utf8");
         const parsed = JSON.parse(raw);
         const roots = normalizeRoots(parsed.roots ?? []);
+        const ignores = normalizeIgnores(parsed.ignores);
+        const ignoredPaths = normalizeIgnoredPaths(parsed.ignoredPaths);
+        const slugParentFolders = normalizeSlugParentFolders(parsed.slugParentFolders);
         return {
             ...DEFAULT_APP_CONFIG,
             version: parsed.version ?? 1,
             roots,
+            ...(ignores !== undefined && { ignores }),
+            ...(ignoredPaths !== undefined && { ignoredPaths }),
+            ...(slugParentFolders !== undefined && { slugParentFolders }),
         };
     }
     catch (error) {
@@ -108,6 +132,9 @@ export async function writeConfig(config) {
     const appConfig = {
         version: config.version,
         roots: config.roots,
+        ...(config.ignores !== undefined && { ignores: config.ignores }),
+        ...(config.ignoredPaths !== undefined && { ignoredPaths: config.ignoredPaths }),
+        ...(config.slugParentFolders !== undefined && { slugParentFolders: config.slugParentFolders }),
     };
     const projectsConfig = {
         projects: config.projects,