decorated-pi 0.7.1 → 0.7.3

package/README.md

@@ -14,25 +14,34 @@ pi install /path/to/decorated-pi
 
 ### 1. Token Efficiency
 
-Multiple layers of token savings that compound across every session. **All integrated CLI tools only require installing their respective CLIs — zero config**.
+Multiple layers of token savings that compound across every session. 
 
-**RTK** — integrates [RTK](https://github.com/rtk-ai/rtk) to compress bash output into structured summaries, so the LLM never sees raw noise.
+**RTK** — integrates [RTK](https://github.com/rtk-ai/rtk) to compress bash output into structured summaries, so the LLM never sees raw noise. **Just install the CLI, zero config**.
 
-**codegraph** — integrates [codegraph](https://github.com/colbymchenry/codegraph) to offer a code map of your project, so the LLM can navigate symbols and call graphs without chaining `ls` → `grep` → `read`.
+**Codegraph** — integrates [codegraph](https://github.com/colbymchenry/codegraph) to offer a code map of your project, so the LLM can navigate symbols and call graphs without chaining `ls` → `grep` → `read`. **You should manage the code source index yourself, see [codegraph doc](https://github.com/colbymchenry/codegraph/blob/main/README.md)**.
 
 **Auxiliary Models** — offloads heavy-but-dumb tasks to cheaper models so your primary model only pays for the hard work:
 
-- **Image read fallback** — detects image type via magic bytes, calls a configured vision-capable model, and injects the analysis text, so your main model never touches image tokens
-- **Compact model** — handles context compaction with a smaller model instead of burning main-model capacity
+- **Image Read Fallback** — detects image type via magic bytes, calls a configured vision-capable model, and injects the analysis text, so your main model never touches image tokens
+- **Compact Model** — handles context compaction with a smaller model instead of burning main-model capacity
 
-Configured via `/dp-model`.
+> Configured via `/dp-model`.
 
-**Cache‑friendly design** — stable system prompt prefix:
+**Cache‑friendly Design** — stable system prompt prefix:
 
 - tool definitions, guidelines, and skills are sorted alphabetically so the system prompt is identical across sessions
 - volatile elements like `Current date: …` are stripped before prompt assembly
 - MCP tool schemas are persisted to a local cache, so the tool list stays stable regardless of network conditions or server availability
 
+**Pi Native Prompt Slimming**
+
+- move the default Pi documentation block out of the system prompt and into a builtin `pi-docs` skill, so the docs reference loads on demand instead of sitting in every turn's prompt
+- unregister the native `write` tool, since `bash` can handle it
+
+**Large Result Externalization**
+
+- a `tool_result` hook that catches ANY tool output (bash, read, MCP, etc.) exceeding 30 KB and saves the full content to `/tmp/decorated-pi-results/<tool>-<callId>.txt`. Pi's native truncation still keeps a chunk of the original content in the prompt; this replaces it entirely with a one‑line pointer (`[Output too long, saved to /tmp/…]`) so the LLM knows where the result is and reads it on demand — strictly fewer tokens per turn
+
 ### 2. Smarter Tools
 
 Drop‑in replacements for Pi's built‑in tools, with better UX and fewer wasted turns.
@@ -145,7 +154,7 @@ Example redaction on a `read` / `bash` output:
 
 ## Configuration
 
-Runtime settings in `~/.pi/agent/decorated-pi.json`. Modules can be toggled via `/dp-settings` (changes take effect after `/reload`).
+Runtime settings in `~/.pi/agent/decorated-pi.json`. run `/dp-settings` to configure it.
 
 ```json
 {
@@ -166,10 +175,22 @@ Runtime settings in `~/.pi/agent/decorated-pi.json`. Modules can be toggled via
       "retry": true,
       "usage": true
     }
+  },
+  "dependencies": {
+    "rtk": {
+      "path": "/custom/bin/rtk",
+      "dontBother": false
+    },
+    "wakatime-cli": {
+      "dontBother": true
+    }
   }
 }
 ```
 
+- `modules` can be toggled on/off to enable/disable features. All are enabled by default.
+- `dependencies[binaryName].path` overrides the lookup location for a binary (file or directory). `dependencies[binaryName].dontBother` silences missing-dependency notifications for that binary. Both are optional
+
 ## License
 
 MIT

package/commands/dp-settings.ts

@@ -1,5 +1,5 @@
 /**
- * /dp-settings — toggle module on/off.
+ * /dp-settings — settings for decorated-pi.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -8,12 +8,12 @@ import { ModuleSettingsComponent } from "../ui/module-settings.js";
 
 export function registerDpSettingsCommand(pi: ExtensionAPI): void {
   pi.registerCommand("dp-settings", {
-    description: "Toggle decorated-pi modules on/off",
+    description: "Settings for decorated-pi",
     handler: async (_args, ctx) => {
       if (ctx.hasUI) {
         await ctx.ui.custom<void>(
           (tui, theme, _kb, done) =>
-            new ModuleSettingsComponent(tui, theme, () => done(undefined))
+            new ModuleSettingsComponent(tui, theme, ctx.ui, () => done(undefined))
         );
         // Only prompt for reload when the effective settings differ from
         // the snapshot taken when pi loaded the extension.

package/hooks/compaction.ts

@@ -1,13 +1,18 @@
 /**
  * compaction — custom compaction model + auto-resume.
  *
- * Uses the configured compact model (from settings.ts) to summarize messages
- * on session_before_compact. After auto-compaction, sends a "continue" message
- * to resume the agent loop.
+ * On `session_before_compact`, runs pi-coding-agent's `compact()` against
+ * the model configured in settings (rather than the agent's current model)
+ * and returns the result so pi uses our summary instead of running its
+ * default. If the configured model is missing, auth fails, or the call
+ * throws, we fall through (return undefined) and pi runs its own compaction.
+ *
+ * On `session_compact`, if the compaction was auto-triggered, sends a
+ * "continue" message to resume the agent loop.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { generateSummary, convertToLlm, serializeConversation } from "@earendil-works/pi-coding-agent";
+import { compact } from "@earendil-works/pi-coding-agent";
 import type { Model } from "@earendil-works/pi-ai";
 import { isContextOverflow } from "@earendil-works/pi-ai";
 import * as fs from "node:fs";
@@ -19,7 +24,6 @@ import type { Module, Skeleton } from "./skeleton.js";
 
 interface PiCompactionSettings {
   enabled: boolean;
-  reserveTokens: number;
 }
 
 interface AutoCompactionCandidate {
@@ -29,7 +33,6 @@ interface AutoCompactionCandidate {
 
 const DEFAULT_PI_COMPACTION_SETTINGS: PiCompactionSettings = {
   enabled: true,
-  reserveTokens: 16_384,
 };
 
 function readJsonObject(filePath: string): any | undefined {
@@ -52,7 +55,6 @@ function loadPiCompactionSettings(cwd: string): PiCompactionSettings {
   };
   return {
     enabled: merged.enabled !== false,
-    reserveTokens: typeof merged.reserveTokens === "number" ? merged.reserveTokens : DEFAULT_PI_COMPACTION_SETTINGS.reserveTokens,
   };
 }
 
@@ -63,30 +65,24 @@ function getLastAssistantMessage(messages: any[]): any | undefined {
   return undefined;
 }
 
-function shouldExpectAutoCompaction(
-  messages: any[],
-  usage: { tokens: number | null; contextWindow: number } | undefined,
-  settings: PiCompactionSettings,
-): boolean {
-  if (!settings.enabled) return false;
-  const lastAssistant = getLastAssistantMessage(messages);
-  if (!lastAssistant) return false;
-  const contextWindow = usage?.contextWindow ?? 0;
-  if (contextWindow > 0 && isContextOverflow(lastAssistant, contextWindow)) return true;
-  if (!usage || usage.tokens === null) return false;
-  return usage.tokens > usage.contextWindow - settings.reserveTokens;
-}
-
+/** Mirror pi's _runAutoCompaction(reason, willRetry) decision:
+ *   - overflow → willRetry=true → auto-resume the agent
+ *   - threshold → willRetry=false → no auto-resume (user continues manually)
+ *   - manual /compact → no resume
+ * Detected from the post-agent-end candidate: overflow shows up as a
+ * context-overflow error on the last assistant message; threshold is a
+ * pre-emptive compaction and we intentionally skip auto-resume for it. */
 function shouldAutoResumeCompaction(
-  prePromptCompactionPending: boolean,
-  postAgentEndCandidate: AutoCompactionCandidate | null,
+  candidate: AutoCompactionCandidate | null,
   settings: PiCompactionSettings,
   customInstructions?: string,
 ): boolean {
   if (customInstructions !== undefined) return false;
-  if (prePromptCompactionPending) return true;
-  if (!postAgentEndCandidate) return false;
-  return shouldExpectAutoCompaction(postAgentEndCandidate.messages, postAgentEndCandidate.usage, settings);
+  if (!candidate || !settings.enabled) return false;
+  const lastAssistant = getLastAssistantMessage(candidate.messages);
+  if (!lastAssistant) return false;
+  const contextWindow = candidate.usage?.contextWindow ?? 0;
+  return contextWindow > 0 && isContextOverflow(lastAssistant, contextWindow);
 }
 
 function getConfiguredCompactModel(registry: any): Model<any> | null {
@@ -97,92 +93,127 @@ function getConfiguredCompactModel(registry: any): Model<any> | null {
   return registry.find(parsed.provider, parsed.modelId) ?? null;
 }
 
-const TURN_PREFIX_PROMPT = `Summarize this turn prefix to provide context for the retained suffix. Be concise. Focus on what's needed to understand the kept suffix.`;
-
-async function generateTurnPrefixSummary(
-  messages: any[], model: Model<any>, reserveTokens: number,
-  apiKey: string, headers: Record<string, string> | undefined, signal: AbortSignal,
-): Promise<string> {
-  const { complete } = await import("@earendil-works/pi-ai");
-  const ct = serializeConversation(convertToLlm(messages));
-  const resp = await complete(model, {
-    systemPrompt: "You are a context summarization assistant. Produce a structured summary only.",
-    messages: [{ role: "user" as const, content: [{ type: "text" as const, text: `<conversation>\n${ct}\n</conversation>\n\n${TURN_PREFIX_PROMPT}` }], timestamp: Date.now() }],
-  }, { maxTokens: Math.floor(0.5 * reserveTokens), signal, apiKey, headers });
-  if (resp.stopReason === "error") throw new Error(resp.errorMessage ?? "Turn prefix summarization failed");
-  return resp.content.filter((c): c is { type: "text"; text: string } => c.type === "text").map(c => c.text).join("\n");
+/** Per-session state. Indexed by sessionId (from ctx.sessionManager) so
+ *  two concurrent pi sessions don't trample each other's flags. */
+interface SessionState {
+  postAgentEndCandidate: AutoCompactionCandidate | null;
+  currentCompactionIsAuto: boolean;
 }
 
-let prePromptCompactionPending = false;
-let postAgentEndCandidate: AutoCompactionCandidate | null = null;
-let currentCompactionIsAuto = false;
+const sessionStates = new Map<string, SessionState>();
+
+function getSessionState(sessionId: string): SessionState {
+  let s = sessionStates.get(sessionId);
+  if (!s) {
+    s = { postAgentEndCandidate: null, currentCompactionIsAuto: false };
+    sessionStates.set(sessionId, s);
+  }
+  return s;
+}
 
 export const compactionModule: Module = {
   name: "compaction",
   hooks: {
-    input: [() => { prePromptCompactionPending = true; postAgentEndCandidate = null; }],
-    before_agent_start: [() => { prePromptCompactionPending = false; postAgentEndCandidate = null; }],
-    agent_start: [() => { prePromptCompactionPending = false; postAgentEndCandidate = null; }],
+    session_shutdown: [
+      (_event, ctx) => {
+        // Clean up state when the session ends so the Map doesn't grow.
+        sessionStates.delete(ctx.sessionManager.getSessionId());
+      },
+    ],
+    input: [
+      (_event, ctx) => {
+        getSessionState(ctx.sessionManager.getSessionId()).postAgentEndCandidate = null;
+      },
+    ],
+    before_agent_start: [
+      (_event, ctx) => {
+        getSessionState(ctx.sessionManager.getSessionId()).postAgentEndCandidate = null;
+      },
+    ],
+    agent_start: [
+      (_event, ctx) => {
+        getSessionState(ctx.sessionManager.getSessionId()).postAgentEndCandidate = null;
+      },
+    ],
     agent_end: [
       (event, ctx) => {
-        prePromptCompactionPending = false;
-        postAgentEndCandidate = { messages: event.messages, usage: ctx.getContextUsage() };
+        getSessionState(ctx.sessionManager.getSessionId()).postAgentEndCandidate = {
+          messages: event.messages,
+          usage: ctx.getContextUsage(),
+        };
       },
     ],
     session_before_compact: [
-      async (event, ctx) => {
+      async (event, ctx, pi) => {
+        const sessionState = getSessionState(ctx.sessionManager.getSessionId());
         const compactionSettings = loadPiCompactionSettings(ctx.cwd);
-        const { isContextOverflow } = await import("@earendil-works/pi-ai");
-        const isAuto = shouldExpectAutoCompaction(
-          postAgentEndCandidate?.messages ?? [],
-          postAgentEndCandidate?.usage,
+        // Pi only auto-compacts after agent_end (see _checkCompaction in
+        // agent-session.js), so we detect "auto" via the post-agent-end
+        // overflow heuristic. Manual /compact carries customInstructions
+        // and skips auto-resume.
+        const isAutoResume = shouldAutoResumeCompaction(
+          sessionState.postAgentEndCandidate,
           compactionSettings,
+          event.customInstructions,
         );
-        // For simplicity, treat session_before_compact as auto if recent agent_end was likely-overflow
-        // and no custom instructions given.
-        const isAutoResume = isAuto && !event.customInstructions;
-        currentCompactionIsAuto = isAutoResume;
-        prePromptCompactionPending = false;
-        postAgentEndCandidate = null;
+        sessionState.postAgentEndCandidate = null;
 
         const model = getConfiguredCompactModel(ctx.modelRegistry);
-        if (!model) return;
+        if (!model) return; // No custom compact model configured → let pi run its default compaction.
         const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
         if (!auth.ok) {
           if (ctx.hasUI) ctx.ui.notify(`Compact model auth failed: ${auth.error}`, "warning");
-          return;
+          return; // Auth failed → fall through to default compaction; pi handles its own resume.
         }
         const { preparation, customInstructions, signal } = event;
-        const { messagesToSummarize, turnPrefixMessages, isSplitTurn, tokensBefore, firstKeptEntryId, previousSummary, settings } = preparation;
-        if (ctx.hasUI) ctx.ui.notify(`🗜️ Compacting with ${model.id} (${tokensBefore.toLocaleString()} tokens)...`, "info");
+        if (ctx.hasUI) {
+          ctx.ui.notify(
+            `🗜️ Compacting with ${model.id} (${preparation.tokensBefore.toLocaleString()} tokens)...`,
+            "info",
+          );
+        }
+        // Mirror pi's native behavior: compact() uses the agent session's
+        // current thinking level (agent-session.js passes this.thinkingLevel
+        // to compact() in both manual and auto compaction paths).
+        const thinkingLevel = pi.getThinkingLevel();
         try {
-          let summary: string;
-          if (isSplitTurn && turnPrefixMessages.length > 0) {
-            const [hs, ps] = await Promise.all([
-              messagesToSummarize.length > 0
-                ? generateSummary(messagesToSummarize, model, settings.reserveTokens, auth.apiKey ?? "", auth.headers, signal, customInstructions, previousSummary)
-                : Promise.resolve("No prior history."),
-              generateTurnPrefixSummary(turnPrefixMessages, model, settings.reserveTokens, auth.apiKey ?? "", auth.headers, signal),
-            ]);
-            summary = `${hs}\n\n---\n\n**Turn Context (split turn):**\n\n${ps}`;
-          } else {
-            summary = await generateSummary(messagesToSummarize, model, settings.reserveTokens, auth.apiKey ?? "", auth.headers, signal, customInstructions, previousSummary);
-          }
-          // session_before_compact is a parallel event — handlers may not
-          // return a value (skeleton discards compose returns for
-          // non-compose events). The summary is intentionally lost; the
-          // session_compact handler below only reads the
-          // currentCompactionIsAuto flag and does not consume the summary.
+          // Delegate to pi-coding-agent's compact() — it does both
+          // summarization (using our model) and file-op extraction, and
+          // returns the exact CompactionResult shape pi's runner expects.
+          const result = await compact(
+            preparation,
+            model,
+            auth.apiKey ?? "",
+            auth.headers,
+            customInstructions,
+            signal,
+            thinkingLevel,
+          );
+          // Only mark as auto-resumed if OUR hook did the compaction. If we
+          // had fallen through to pi's default path above, pi's own
+          // _runAutoCompaction would call agent.continue() on overflow;
+          // marking here would cause a duplicate resume message on top.
+          sessionState.currentCompactionIsAuto = isAutoResume;
+          return { compaction: result };
         } catch (err) {
           if (signal.aborted) return;
-          if (ctx.hasUI) ctx.ui.notify(`Compact failed: ${err instanceof Error ? err.message : err}`, "error");
+          // Returning undefined lets pi run its default compaction with the
+          // active agent model. Surface the failure so the user knows their
+          // custom model didn't take effect.
+          if (ctx.hasUI) {
+            ctx.ui.notify(
+              `Custom compact failed (${err instanceof Error ? err.message : err}); using default model.`,
+              "warning",
+            );
+          }
         }
       },
     ],
     session_compact: [
-      (_event, _ctx, pi) => {
-        const shouldResume = currentCompactionIsAuto;
-        currentCompactionIsAuto = false;
+      (_event, ctx, pi) => {
+        const sessionState = getSessionState(ctx.sessionManager.getSessionId());
+        const shouldResume = sessionState.currentCompactionIsAuto;
+        sessionState.currentCompactionIsAuto = false;
         if (!shouldResume) return;
         pi.sendMessage({
           customType: "auto_compact_resume",
@@ -199,6 +230,5 @@ export function setupCompaction(sk: Skeleton): void {
 }
 
 export const __modelIntegrationTest = {
-  shouldExpectAutoCompaction,
   shouldAutoResumeCompaction,
 };

package/hooks/externalize.ts

@@ -14,7 +14,10 @@ import * as path from "node:path";
 import { randomBytes } from "node:crypto";
 import type { Module } from "./skeleton.js";
 
-export const TOOL_OUTPUT_TEMP_DIR = path.join(os.tmpdir(), "decorated-pi-results");
+export const TOOL_OUTPUT_TEMP_DIR = path.join(
+    os.tmpdir(),
+    "decorated-pi-results",
+);
 export const OUTPUT_EXTERNALIZE_THRESHOLD = 30_000;
 
 /** Write content to a temp file under TOOL_OUTPUT_TEMP_DIR.
@@ -22,49 +25,59 @@ export const OUTPUT_EXTERNALIZE_THRESHOLD = 30_000;
  *  Exported so other modules (e.g. tools/mcp/externalize.ts) can
  *  write to the same location. */
 export function writeOutputToTemp(
-  toolName: string,
-  toolCallId: string,
-  content: string,
+    toolName: string,
+    toolCallId: string,
+    content: string,
 ): string | undefined {
-  try {
-    if (!fs.existsSync(TOOL_OUTPUT_TEMP_DIR)) fs.mkdirSync(TOOL_OUTPUT_TEMP_DIR, { recursive: true });
-    const id = toolCallId ? toolCallId.slice(0, 12) : randomBytes(8).toString("hex");
-    const filePath = path.join(TOOL_OUTPUT_TEMP_DIR, `${toolName}-${id}.txt`);
-    fs.writeFileSync(filePath, content, "utf-8");
-    return filePath;
-  } catch {
-    return undefined;
-  }
+    try {
+        if (!fs.existsSync(TOOL_OUTPUT_TEMP_DIR))
+            fs.mkdirSync(TOOL_OUTPUT_TEMP_DIR, { recursive: true });
+        const id = toolCallId
+            ? toolCallId.slice(0, 12)
+            : randomBytes(8).toString("hex");
+        const filePath = path.join(
+            TOOL_OUTPUT_TEMP_DIR,
+            `${toolName}-${id}.txt`,
+        );
+        fs.writeFileSync(filePath, content, "utf-8");
+        return filePath;
+    } catch {
+        return undefined;
+    }
 }
 
 /** Externalize a tool_result event if content is above the threshold.
  *  Returns the modified event, or undefined to leave the original untouched. */
 export function maybeExternalizeToolResult(event: any): any | undefined {
-  if (!Array.isArray(event.content) || event.content.length === 0) return undefined;
-  const first = event.content[0];
-  if (!first || first.type !== "text" || typeof first.text !== "string") return undefined;
-  const text = first.text;
-  if (text.length <= OUTPUT_EXTERNALIZE_THRESHOLD) return undefined;
+    if (!Array.isArray(event.content) || event.content.length === 0)
+        return undefined;
+    const first = event.content[0];
+    if (!first || first.type !== "text" || typeof first.text !== "string")
+        return undefined;
+    const text = first.text;
+    if (text.length <= OUTPUT_EXTERNALIZE_THRESHOLD) return undefined;
 
-  const filePath = writeOutputToTemp(event.toolName, event.toolCallId, text);
-  if (!filePath) return undefined;
+    const filePath = writeOutputToTemp(event.toolName, event.toolCallId, text);
+    if (!filePath) return undefined;
 
-  return {
-    ...event,
-    content: [{
-      type: "text" as const,
-      text: `[Output truncated: ${text.length.toLocaleString()} chars. Full output: ${filePath}]`,
-    }],
-  };
+    return {
+        ...event,
+        content: [
+            {
+                type: "text" as const,
+                text: `[Output too long, saved to ${filePath}.]`,
+            },
+        ],
+    };
 }
 
 export const externalizeModule: Module = {
-  name: "externalize",
-  hooks: {
-    tool_result: [
-      (event) => {
-        return maybeExternalizeToolResult(event);
-      },
-    ],
-  },
+    name: "externalize",
+    hooks: {
+        tool_result: [
+            (event) => {
+                return maybeExternalizeToolResult(event);
+            },
+        ],
+    },
 };

package/hooks/inject-agents-md.ts

@@ -9,6 +9,17 @@ import { dirname, resolve, relative, join, normalize } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import type { Module } from "./skeleton.js";
 
+function isInsideSkillDir(filePath: string): boolean {
+    let dir = dirname(resolve(filePath));
+    while (true) {
+        if (existsSync(join(dir, "SKILL.md"))) return true;
+        const parent = dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return false;
+}
+
 const CUSTOM_TYPE = "decorated-pi.subdir-agents";
 const AGENTS_NAMES = ["AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"];
 
@@ -86,7 +97,12 @@ function findNewAgents(
     return results.reverse();
 }
 
-export const __subdirAgentsTest = { restoreFromBranch, findNewAgents };
+export const __subdirAgentsTest = { restoreFromBranch, findNewAgents, isInsideSkillDir };
+
+export const INJECT_AGENTS_MD_GUIDANCE = [
+    "### Context Loading, AGENTS.md / CLAUDE.md are auto-injected",
+    "- DO NOT read any **AGENTS.md** or **CLAUDE.md** files unless you're explicitly asked to, these files will loaded automatically if necessary.",
+].join("\n");
 
 export const injectAgentsMdModule: Module = {
     name: "inject-agents-md",
@@ -111,7 +127,9 @@ export const injectAgentsMdModule: Module = {
                 if (event.toolName !== "read" && event.toolName !== "edit")
                     return;
                 const path = (event.input as { path?: string })?.path;
-                if (path) pendingPaths.set(event.toolCallId, path);
+                if (!path) return;
+                if (isInsideSkillDir(resolve(path))) return;
+                pendingPaths.set(event.toolCallId, path);
             },
         ],
         tool_result: [
@@ -152,13 +170,3 @@ export const injectAgentsMdModule: Module = {
         ],
     },
 };
-
-/**
- * System-prompt guidance for the inject-agents-md hook — tells the
- * LLM not to waste tool calls re-reading AGENTS.md / CLAUDE.md, since
- * this hook already auto-injects them.
- */
-export const INJECT_AGENTS_MD_GUIDANCE = [
-    "### Context Loading, AGENTS.md / CLAUDE.md are auto-injected",
-    "- DO NOT read any **AGENTS.md** or **CLAUDE.md** files unless you're explicitly asked to, these files will loaded automatically if necessary.",
-].join("\n");