@docyrus/docyrus 0.0.21 → 0.0.23

package/resources/pi-agent/extensions/pi-custom-compaction/README.md

@@ -0,0 +1,244 @@
+<p>
+  <img src="banner.png" alt="pi-custom-compaction" width="1100">
+</p>
+
+# pi-custom-compaction
+
+Swap the model and template Pi uses for compaction. Optionally trigger compaction at a specific token count.
+
+Once enabled, the extension intercepts every compaction — whether triggered by Pi's built-in or by the extension itself — and uses your configured model and template to generate the summary. If all configured models fail to resolve, it falls back to Pi's built-in compaction silently.
+
+Off by default. Pi's built-in compaction works normally until you enable it.
+
+## Installation
+
+```bash
+pi install npm:pi-custom-compaction
+```
+
+## Quick start
+
+Create `~/.pi/agent/compaction-policy.json` (global) or `<project>/.pi/compaction-policy.json` (project, takes priority):
+
+```json
+{
+  "enabled": true,
+  "models": [
+    { "model": "anthropic/claude-sonnet-4", "thinkingLevel": "medium" }
+  ]
+}
+```
+
+Run `/reload`. Done. Pi still decides when to compact — you just swapped the model.
+
+To also control **when** it triggers:
+
+```json
+{
+  "enabled": true,
+  "trigger": { "maxTokens": 350000 },
+  "ui": { "name": "ctx" },
+  "models": [
+    { "model": "anthropic/claude-haiku-4-5", "thinkingLevel": "medium" },
+    { "model": "openai-codex/gpt-5.3-codex", "thinkingLevel": "low" }
+  ]
+}
+```
+
+Status bar shows: `ctx · 24.7% (86426/350000)`
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `/compact-policy` | Shows effective config (models, trigger, profile, template) |
+| `/compact-now [focus]` | Triggers compaction immediately |
+
+## Models
+
+Ordered fallback chain. Tries each model in order, uses the first one that resolves. If credits run out on one, the next takes over.
+
+Plain strings inherit base `summary` settings. Objects let you override per model:
+
+```json
+"models": [
+  { "model": "anthropic/claude-sonnet-4", "thinkingLevel": "medium" },
+  "openai-codex/gpt-5.3-codex"
+]
+```
+
+## Trigger
+
+| Key | What it does | Default |
+| --- | --- | --- |
+| `maxTokens` | Compact at this token count. Omit to let Pi decide. | — |
+| `minTokens` | Won't trigger below this count | 100000 |
+| `cooldownMs` | Min time between proactive compactions | 60000 |
+
+`maxTokens` makes compaction happen sooner. Without it, Pi waits until the context window is almost full (~984K on a 1M model). With `maxTokens: 350000`, compaction fires at 350K instead.
+
+## How maxTokens interacts with the context window
+
+You don't need to tune `maxTokens` per model. One config works across models with different context sizes:
+
+- **Well below context window** (350K on a 1M model) — extension fires at 350K, plenty of room for the summary.
+- **Close to context window** (260K on a 272K model) — extension backs off and lets Pi's built-in fire at 256K with its own reserve, preventing double-compaction.
+- **Larger than context window** (350K on a 272K model) — proactive trigger can never fire, Pi handles it at 256K.
+
+<details>
+<summary>Advanced trigger tuning</summary>
+
+| Key | What it does | Default |
+| --- | --- | --- |
+| `builtinReserveTokens` | Tokens Pi's built-in reserves before triggering | 16384 |
+| `builtinSkipMarginPercent` | Skip if Pi's builtin would trigger within this margin | 5 |
+
+</details>
+
+## Profiles
+
+Override trigger, models, and summary settings per session model:
+
+```json
+"profiles": {
+  "opus-large-ctx": {
+    "match": "anthropic/claude-opus-4-6",
+    "trigger": { "maxTokens": 500000 },
+    "models": [{ "model": "anthropic/claude-haiku-4-5", "thinkingLevel": "medium" }],
+    "template": "~/.pi/agent/templates/opus.md",
+    "updateTemplate": "~/.pi/agent/templates/opus-update.md"
+  },
+  "fast-codex": {
+    "match": "openai-codex/gpt-5.3-codex",
+    "models": ["openai-codex/gpt-5.3-codex"],
+    "summary": { "thinkingLevel": "low" }
+  }
+}
+```
+
+`match` is the exact `provider/modelId` of the session model. First alphabetical match wins. Profile `models` replaces the base models list for that session. `template` and `updateTemplate` override template discovery with explicit paths (tilde-expanded). Active profile shows in the status bar.
+
+## Templates (optional)
+
+Without a template, Pi's built-in compaction format is used. To customize the summary structure, drop markdown files at convention paths — no config needed.
+
+Two template types:
+- **Initial** (`compaction-template.md`) — first compaction, brackets describe what to extract
+- **Update** (`compaction-template-update.md`) — subsequent compactions, brackets describe how to merge (optional, falls back to initial)
+
+Discovery order (first found wins):
+
+```
+Initial template:
+  <project>/.pi/compaction-templates/PROFILE.md
+  ~/.pi/agent/compaction-templates/PROFILE.md
+  <project>/.pi/compaction-template.md
+  ~/.pi/agent/compaction-template.md
+
+Update template:
+  <project>/.pi/compaction-templates/PROFILE-update.md
+  ~/.pi/agent/compaction-templates/PROFILE-update.md
+  <project>/.pi/compaction-template-update.md
+  ~/.pi/agent/compaction-template-update.md
+```
+
+Profile-specific paths are only checked when a profile is active. Template files are never modified — they're format definitions read on every compaction. The model fills in the brackets based on the conversation.
+
+Example initial template (`compaction-template.md`):
+
+```markdown
+## Goal
+[What is the user trying to accomplish? Can be multiple items if the session covers different tasks.]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned by user]
+- [Or "(none)" if none were mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks/changes]
+
+### In Progress
+- [ ] [Current work]
+
+### Blocked
+- [Issues preventing progress, if any]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale]
+
+## Next Steps
+1. [Ordered list of what should happen next]
+
+## Critical Context
+- [Any data, examples, or references needed to continue]
+- [Or "(none)" if not applicable]
+```
+
+Example update template (`compaction-template-update.md`):
+
+```markdown
+## Goal
+[Preserve existing goals, add new ones if the task expanded]
+
+## Constraints & Preferences
+- [Preserve existing, add new ones discovered]
+
+## Progress
+### Done
+- [x] [Include previously done items AND newly completed items]
+
+### In Progress
+- [ ] [Current work - update based on progress]
+
+### Blocked
+- [Current blockers - remove if resolved]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale] (preserve all previous, add new)
+
+## Next Steps
+1. [Update based on current state]
+
+## Critical Context
+- [Preserve important context, add new if needed]
+```
+
+`summary.preservationInstruction` is appended as an extra directive after the template.
+
+## UI options
+
+```json
+"ui": {
+  "name": "ctx",
+  "showStatus": true,
+  "minimalStatus": false,
+  "quiet": false
+}
+```
+
+| Key | What it does | Default |
+| --- | --- | --- |
+| `name` | Status bar label | `"compact"` |
+| `showStatus` | Show status bar | `true` |
+| `minimalStatus` | Short format (just percentage) | `false` |
+| `quiet` | Suppress non-critical notifications | `false` |
+
+Status bar examples:
+
+```
+ctx · 24.7% (86426/350000)
+ctx: opus-large-ctx · 50.1% (250500/500000)
+ctx · 31%
+```
+
+## Summary options
+
+```json
+"summary": {
+  "thinkingLevel": "medium",
+  "preservationInstruction": "Preserve exact file paths, function names, and error messages."
+}
+```
+
+These are base settings. Model entries and profiles can override `thinkingLevel` and `preservationInstruction` individually.

package/resources/pi-agent/extensions/pi-custom-compaction/VENDORED_FROM.md

@@ -0,0 +1,6 @@
+Vendored from [`nicobailon/pi-custom-compaction`](https://github.com/nicobailon/pi-custom-compaction)
+
+- Upstream commit: `ac69e833c4dc00b4961c65daa2807017bed86e8b`
+- Vendored for: `docyrus agent` / `docyrus coder`
+- Local adaptation:
+  - prefer `PI_CODING_AGENT_DIR` for global policy/template lookup so scoped Docyrus agent state works

package/resources/pi-agent/extensions/pi-custom-compaction/commands/register-commands.ts

@@ -0,0 +1,63 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { resolveEffectivePolicy } from "../runtime/pure.js";
+import type { IRuntimeServices } from "../runtime/session-state.js";
+import { discoverTemplate } from "../summary/template.js";
+
+function formatModels(policy: { models: Array<{ model: string; thinkingLevel?: string }> }): string {
+  return policy.models
+    .map((e) => (e.thinkingLevel ? `${e.model} (thinking: ${e.thinkingLevel})` : e.model))
+    .join(" → ");
+}
+
+function formatTrigger(policy: {
+	trigger: { maxTokens?: number; minTokens: number; cooldownMs: number };
+}): string {
+  const { maxTokens, minTokens, cooldownMs } = policy.trigger;
+  const threshold = maxTokens && maxTokens > 0 ? `${maxTokens} tokens` : "inherited from pi";
+  return `${threshold} | minTokens: ${minTokens} | cooldown: ${cooldownMs}ms`;
+}
+
+export function registerCommands(pi: ExtensionAPI, runtime: IRuntimeServices): void {
+  pi.registerCommand("compact-policy", {
+    description: "Show current compaction policy",
+    handler: async(_args, ctx: ExtensionCommandContext) => {
+      const basePolicy = runtime.loadEffectivePolicy(ctx);
+      const { policy, profileName, sessionModel, profileTemplates } = resolveEffectivePolicy(ctx, basePolicy);
+      const template = discoverTemplate(ctx.cwd, profileName, profileTemplates);
+      const templatePath = template.fallbackReason
+        ? `${template.resolvedPath ?? "(unknown)"} (invalid: ${template.fallbackReason}; using built-in)`
+        : template.resolvedPath ?? "(none — using built-in)";
+      const updateTemplatePath = template.updateFallbackReason
+        ? `${template.updateResolvedPath ?? "(unknown)"} (invalid: ${template.updateFallbackReason}; using initial template)`
+        : template.updateResolvedPath ?? "(none — using initial template)";
+
+      const lines = [
+        `enabled: ${policy.enabled}`,
+        `models: ${formatModels(policy)}`,
+        `trigger: ${formatTrigger(policy)}`,
+        `summary: thinking=${policy.summary.thinkingLevel}`,
+        `session model: ${sessionModel ?? "unknown"}`,
+        `profile: ${profileName ?? "none"}`,
+        `template: ${templatePath}`,
+        `template update: ${updateTemplatePath}`,
+      ];
+      ctx.ui.notify(lines.join("\n"), "info");
+    },
+  });
+
+  pi.registerCommand("compact-now", {
+    description: "Trigger compaction immediately",
+    handler: async(args, ctx: ExtensionCommandContext) => {
+      const basePolicy = runtime.loadEffectivePolicy(ctx);
+      const { policy, profileName } = resolveEffectivePolicy(ctx, basePolicy);
+      runtime.setActiveProfileName(profileName);
+
+      const focus = args.trim() || undefined;
+      if (!policy.enabled) {
+        ctx.compact({ customInstructions: focus });
+        return;
+      }
+      runtime.triggerCompaction(ctx, policy, "compact-now", focus);
+    },
+  });
+}

package/resources/pi-agent/extensions/pi-custom-compaction/events/register-events.ts

@@ -0,0 +1,229 @@
+import type { Api, Model } from "@mariozechner/pi-ai";
+import { compact, type ExtensionAPI, type ExtensionContext, type SessionBeforeCompactEvent } from "@mariozechner/pi-coding-agent";
+import type { ISummaryPolicy } from "../policy/types.js";
+import {
+  computeFileLists,
+  formatFileOperations,
+  generateTemplateSummary,
+  generateTurnPrefixSummary,
+  getReserveTokens,
+} from "../summary/generate.js";
+import { buildSummaryPrompt, discoverTemplate, resolveSummarySettings } from "../summary/template.js";
+import { getLastAssistantMessage, resolveSummaryModel } from "../runtime/model-resolution.js";
+import { resolveEffectivePolicy, shouldTriggerProactiveCompact } from "../runtime/pure.js";
+import type { IRuntimeServices } from "../runtime/session-state.js";
+
+async function generateCustomCompaction(
+  event: SessionBeforeCompactEvent,
+  template: string,
+  updateTemplate: string | undefined,
+  summarySettings: ISummaryPolicy,
+  model: Model<Api>,
+  apiKey: string,
+) {
+  const reserveTokens = getReserveTokens(event);
+  const summaryPrompt = buildSummaryPrompt(
+    template,
+    updateTemplate,
+    event.preparation.previousSummary,
+    event.customInstructions,
+    summarySettings.preservationInstruction,
+  );
+  const historySummary =
+		event.preparation.messagesToSummarize.length > 0
+		  ? await generateTemplateSummary(
+		    event.preparation.messagesToSummarize,
+		    model,
+		    apiKey,
+		    summaryPrompt,
+		    reserveTokens,
+		    event.signal,
+		    summarySettings.thinkingLevel,
+		    event.preparation.previousSummary,
+			  )
+		  : event.preparation.previousSummary ?? "No prior history.";
+  if (!historySummary.trim()) {
+    throw new Error("Custom template summarization returned empty summary");
+  }
+
+  const turnPrefixSummary =
+		event.preparation.isSplitTurn && event.preparation.turnPrefixMessages.length > 0
+		  ? await generateTurnPrefixSummary(
+		    event.preparation.turnPrefixMessages,
+		    model,
+		    apiKey,
+		    reserveTokens,
+		    event.signal,
+		    summarySettings.thinkingLevel,
+			  )
+		  : undefined;
+  if (turnPrefixSummary !== undefined && !turnPrefixSummary.trim()) {
+    throw new Error("Turn prefix summarization returned empty summary");
+  }
+
+  const mergedSummary = turnPrefixSummary
+    ? `${historySummary}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixSummary}`
+    : historySummary;
+  const details = computeFileLists(event.preparation.fileOps);
+  const summary = `${mergedSummary}${formatFileOperations(details)}`;
+  return {
+    summary,
+    firstKeptEntryId: event.preparation.firstKeptEntryId,
+    tokensBefore: event.preparation.tokensBefore,
+    details,
+  };
+}
+
+function initializeSessionStatus(ctx: ExtensionContext, runtime: IRuntimeServices): void {
+  const basePolicy = runtime.loadEffectivePolicy(ctx, { warnOnInvalidConfig: false });
+  if (!basePolicy.enabled) {return;}
+  const { policy, profileName } = resolveEffectivePolicy(ctx, basePolicy);
+  runtime.setActiveProfileName(profileName);
+  runtime.updateStatus(ctx, policy);
+}
+
+export function registerEvents(pi: ExtensionAPI, runtime: IRuntimeServices): void {
+  pi.on("agent_end", async(event, ctx) => {
+    const basePolicy = runtime.loadEffectivePolicy(ctx, { warnOnInvalidConfig: false });
+    if (!basePolicy.enabled) {
+      runtime.clearInFlight();
+      runtime.setActiveProfileName(undefined);
+      runtime.updateStatus(ctx, basePolicy);
+      return;
+    }
+
+    const { policy, profileName } = resolveEffectivePolicy(ctx, basePolicy);
+    runtime.setActiveProfileName(profileName);
+
+    const shouldTrigger = shouldTriggerProactiveCompact({
+      lastAssistantMessage: getLastAssistantMessage(event.messages),
+      usage: ctx.getContextUsage(),
+      inFlight: runtime.isInFlight(),
+      nowMs: Date.now(),
+      lastProactiveAtMs: runtime.getLastProactiveAtMs(),
+      policy,
+    });
+    if (!shouldTrigger) {
+      runtime.updateStatus(ctx, policy);
+      return;
+    }
+
+    const triggered = runtime.triggerCompaction(ctx, policy, "proactive");
+    if (triggered) {
+      runtime.setLastProactiveAtMs(Date.now());
+    }
+  });
+
+  pi.on("session_before_compact", async(event, ctx) => {
+    const basePolicy = runtime.loadEffectivePolicy(ctx, { warnOnInvalidConfig: false });
+    if (!basePolicy.enabled) {
+      runtime.clearInFlight();
+      runtime.setActiveProfileName(undefined);
+      runtime.updateStatus(ctx, basePolicy);
+      return undefined;
+    }
+
+    const { policy, profileName, profileTemplates } = resolveEffectivePolicy(ctx, basePolicy);
+    runtime.setActiveProfileName(profileName);
+    runtime.setInFlight("session_before_compact");
+    runtime.updateStatus(ctx, policy);
+
+    const resolved = await resolveSummaryModel(ctx, policy, runtime.notify);
+    if (!resolved) {
+      runtime.clearInFlight();
+      return undefined;
+    }
+
+    const summarySettings = resolveSummarySettings(policy, resolved.entry);
+    const templateResolution = discoverTemplate(ctx.cwd, profileName, profileTemplates);
+    if (templateResolution.fallbackReason) {
+      runtime.notify(
+        ctx,
+        policy,
+        "warning",
+        `Could not load summary template ${templateResolution.resolvedPath} (${templateResolution.fallbackReason}). Falling back to built-in compaction format.`,
+        { dedupeKey: `template-fallback:${templateResolution.resolvedPath}:${templateResolution.fallbackReason}` },
+      );
+    }
+    if (templateResolution.updateFallbackReason) {
+      runtime.notify(
+        ctx,
+        policy,
+        "warning",
+        `Could not load update summary template ${templateResolution.updateResolvedPath} (${templateResolution.updateFallbackReason}). Falling back to initial summary template.`,
+        {
+          dedupeKey: `template-update-fallback:${templateResolution.updateResolvedPath}:${templateResolution.updateFallbackReason}`,
+        },
+      );
+    }
+
+    try {
+      const result = templateResolution.template
+        ? await generateCustomCompaction(
+          event,
+          templateResolution.template,
+          templateResolution.updateTemplate,
+          summarySettings,
+          resolved.model,
+          resolved.apiKey,
+				  )
+        : await compact(
+          event.preparation,
+          resolved.model,
+          resolved.apiKey,
+          event.customInstructions,
+          event.signal,
+				  );
+
+      return {
+        compaction: {
+          summary: result.summary,
+          tokensBefore: result.tokensBefore,
+          details: result.details,
+          firstKeptEntryId: result.firstKeptEntryId,
+        },
+      };
+    } catch (error) {
+      runtime.clearInFlight();
+      if (event.signal.aborted) {return undefined;}
+      const message = error instanceof Error ? error.message : String(error);
+      runtime.notify(ctx, policy, "error", `Compaction policy summary failed: ${message}`, {
+        critical: true,
+      });
+      return undefined;
+    }
+  });
+
+  pi.on("session_compact", async(_event, ctx) => {
+    runtime.clearInFlight();
+    runtime.markPostCompact();
+    const basePolicy = runtime.loadEffectivePolicy(ctx, { warnOnInvalidConfig: false });
+    const { policy, profileName } = resolveEffectivePolicy(ctx, basePolicy);
+    runtime.setActiveProfileName(profileName);
+    runtime.updateStatus(ctx, policy);
+  });
+
+  pi.on("session_start", async(_event, ctx) => {
+    runtime.clearSessionScopedState(ctx);
+    initializeSessionStatus(ctx, runtime);
+  });
+
+  pi.on("session_switch", async(_event, ctx) => {
+    runtime.clearSessionScopedState(ctx);
+    initializeSessionStatus(ctx, runtime);
+  });
+
+  pi.on("session_fork", async(_event, ctx) => {
+    runtime.clearSessionScopedState(ctx);
+    initializeSessionStatus(ctx, runtime);
+  });
+
+  pi.on("session_tree", async(_event, ctx) => {
+    runtime.clearSessionScopedState(ctx);
+    initializeSessionStatus(ctx, runtime);
+  });
+
+  pi.on("session_shutdown", async(_event, ctx) => {
+    runtime.clearSessionScopedState(ctx);
+  });
+}

package/resources/pi-agent/extensions/pi-custom-compaction/index.ts

@@ -0,0 +1,10 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { registerCommands } from "./commands/register-commands.js";
+import { registerEvents } from "./events/register-events.js";
+import { createRuntimeServices } from "./runtime/session-state.js";
+
+export default function compactionPolicyExtension(pi: ExtensionAPI) {
+  const runtime = createRuntimeServices();
+  registerCommands(pi, runtime);
+  registerEvents(pi, runtime);
+}

package/resources/pi-agent/extensions/pi-custom-compaction/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "pi-custom-compaction",
+  "version": "0.2.0",
+  "description": "Custom compaction for pi — swap the model, template, and trigger for context compaction",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "compaction",
+    "context-management",
+    "extension"
+  ],
+  "homepage": "https://github.com/nicobailon/pi-custom-compaction#readme",
+  "bugs": {
+    "url": "https://github.com/nicobailon/pi-custom-compaction/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nicobailon/pi-custom-compaction.git"
+  },
+  "license": "MIT",
+  "author": "Nico Bailon",
+  "type": "module",
+  "files": [
+    "index.ts",
+    "commands/register-commands.ts",
+    "events/register-events.ts",
+    "policy/config.ts",
+    "policy/merge.ts",
+    "policy/parse.ts",
+    "policy/types.ts",
+    "runtime/model-resolution.ts",
+    "runtime/pure.ts",
+    "runtime/session-state.ts",
+    "summary/generate.ts",
+    "summary/template.ts",
+    "banner.png",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "tsx --test test/**/*.test.ts"
+  },
+  "devDependencies": {
+    "@mariozechner/pi-agent-core": "^0.57.1",
+    "@mariozechner/pi-ai": "^0.57.1",
+    "@mariozechner/pi-coding-agent": "^0.57.1",
+    "@mariozechner/pi-tui": "^0.57.1",
+    "tsx": "^4.20.5"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/resources/pi-agent/extensions/pi-custom-compaction/paths.ts

@@ -0,0 +1,13 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const LEGACY_PI_AGENT_ROOT = join(homedir(), ".pi", "agent");
+
+export function resolveAgentRootPath(): string {
+  const agentDir = process.env.PI_CODING_AGENT_DIR?.trim();
+  return agentDir && agentDir.length > 0 ? agentDir : LEGACY_PI_AGENT_ROOT;
+}
+
+export function resolveGlobalCompactionPolicyPath(): string {
+  return join(resolveAgentRootPath(), "compaction-policy.json");
+}

package/resources/pi-agent/extensions/pi-custom-compaction/policy/config.ts

@@ -0,0 +1,32 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parsePolicyPatch } from "./parse.js";
+import { resolveGlobalCompactionPolicyPath } from "../paths.js";
+import {
+  CONFIG_FILE,
+  type ICompactionPolicyPatch,
+  type IParseResult,
+} from "./types.js";
+
+function readConfigFile(configPath: string): IParseResult<ICompactionPolicyPatch> {
+  try {
+    const raw = readFileSync(configPath, "utf8");
+    const json = JSON.parse(raw);
+    const parsed = parsePolicyPatch(json);
+    if (!parsed.ok) {
+      return { ok: false, error: `Invalid ${configPath}: ${parsed.error}` };
+    }
+    return parsed;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: `Invalid ${configPath}: ${message}` };
+  }
+}
+
+export function readProjectPolicyPatch(cwd: string): IParseResult<ICompactionPolicyPatch> {
+  const globalConfigPath = resolveGlobalCompactionPolicyPath();
+  const projectPath = join(cwd, CONFIG_FILE);
+  if (existsSync(projectPath)) {return readConfigFile(projectPath);}
+  if (existsSync(globalConfigPath)) {return readConfigFile(globalConfigPath);}
+  return { ok: true, value: {} };
+}