claudenv 1.2.5 → 1.3.1

package/src/hooks/regen-index.js

@@ -0,0 +1,198 @@
+/**
+ * regen-index — SessionEnd hook handler and CLI command for INDEX.md generation.
+ *
+ * Scans ~/.claudenv/memories/decisions/ + <cwd>/.claude/memories/decisions/,
+ * picks the top-N most recent by `date:` frontmatter, and produces a compact
+ * INDEX.md briefing (~30-50 lines) that the next session reads via memory tool
+ * or via `--append-system-prompt` (loop).
+ *
+ * Idempotent. Hard-capped output size so it never bloats the cache.
+ */
+
+import { readFile, writeFile, readdir, mkdir, unlink, stat } from 'node:fs/promises';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+
+const DEFAULT_RECENT_LIMIT = 5;
+const MAX_INDEX_LINES = 60;
+
+// Lazy resolution so tests can override via process.env.CLAUDENV_HOME.
+function claudenvHome() {
+  return process.env.CLAUDENV_HOME || join(homedir(), '.claudenv');
+}
+function memoriesDir() { return join(claudenvHome(), 'memories'); }
+function globalDecisionsDir() { return join(memoriesDir(), 'decisions'); }
+function userPrefsPath() { return join(memoriesDir(), 'user', 'preferences.md'); }
+function indexPath() { return join(memoriesDir(), 'INDEX.md'); }
+function dirtyFlagPath() { return join(claudenvHome(), '.index-dirty'); }
+
+/**
+ * Read YAML frontmatter into a flat object. Same minimal parser as decisions-logger.
+ */
+function parseFrontmatter(text) {
+  const match = /^---\n([\s\S]*?)\n---/.exec(text);
+  if (!match) return null;
+  const result = {};
+  for (const line of match[1].split('\n')) {
+    const m = /^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)$/.exec(line);
+    if (!m) continue;
+    let value = m[2].trim().replace(/^['"]|['"]$/g, '');
+    result[m[1]] = value;
+  }
+  return result;
+}
+
+/**
+ * Collect decision entries from one directory.
+ * @returns {Promise<Array<{file: string, date: string|null, topic: string, chose: string, scope: string}>>}
+ */
+async function collectDecisions(dir, scopeHint) {
+  let names;
+  try {
+    names = await readdir(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (!name.endsWith('.md')) continue;
+    const full = join(dir, name);
+    let text;
+    try {
+      text = await readFile(full, 'utf-8');
+    } catch {
+      continue;
+    }
+    const fm = parseFrontmatter(text) || {};
+    out.push({
+      file: full,
+      name,
+      date: fm.date || null,
+      topic: fm.topic || name.replace(/\.md$/, ''),
+      chose: fm.chose || '',
+      scope: fm.scope || scopeHint,
+    });
+  }
+  return out;
+}
+
+/**
+ * Read user/preferences.md, return summary lines (up to N).
+ */
+async function summarizePrefs(maxLines = 8) {
+  try {
+    const text = await readFile(userPrefsPath(), 'utf-8');
+    return text
+      .split('\n')
+      .map((l) => l.trim())
+      .filter((l) => l.startsWith('- '))
+      .slice(0, maxLines);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Generate INDEX.md content.
+ *
+ * @param {object} [options]
+ * @param {string} [options.cwd] - Project root to include project-scoped decisions from
+ * @param {number} [options.limit] - Max decisions to surface
+ */
+export async function regenIndex(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const limit = options.limit ?? DEFAULT_RECENT_LIMIT;
+
+  const global = await collectDecisions(globalDecisionsDir(), 'global');
+  const project = await collectDecisions(
+    join(cwd, '.claude', 'memories', 'decisions'),
+    'project'
+  );
+
+  const all = [...global, ...project];
+
+  // Sort newest first by date (ISO sorts lexicographically). Missing date = oldest.
+  all.sort((a, b) => {
+    if (!a.date && !b.date) return 0;
+    if (!a.date) return 1;
+    if (!b.date) return -1;
+    return b.date.localeCompare(a.date);
+  });
+
+  const recent = all.slice(0, limit);
+  const prefs = await summarizePrefs();
+
+  const lines = [];
+  lines.push('# claudenv memory — INDEX');
+  lines.push('');
+  lines.push(`> Auto-generated by \`claudenv hook regen-index\`. Last: ${new Date().toISOString()}`);
+  lines.push('');
+
+  lines.push('## Recent decisions');
+  lines.push('');
+  if (recent.length === 0) {
+    lines.push('_No decisions yet. Make a non-trivial technical choice; vibe-decisions will log it._');
+  } else {
+    for (const d of recent) {
+      const date = d.date ? d.date.slice(0, 10) : '?';
+      const scope = d.scope === 'project' ? '[project]' : '[global]';
+      const slug = basename(d.name, '.md');
+      lines.push(`- ${date} ${scope} **${d.topic}** → ${d.chose} (\`${slug}\`)`);
+    }
+  }
+  lines.push('');
+
+  if (prefs.length) {
+    lines.push('## Active preferences');
+    lines.push('');
+    for (const p of prefs) lines.push(p);
+    lines.push('');
+  }
+
+  lines.push('---');
+  lines.push('');
+  lines.push(`Files: ${global.length} global, ${project.length} project decisions. Run \`claudenv decisions list\` for the full set.`);
+
+  // Hard cap to keep cache stable.
+  const capped = lines.slice(0, MAX_INDEX_LINES);
+
+  await mkdir(memoriesDir(), { recursive: true });
+  await writeFile(indexPath(), capped.join('\n') + '\n', 'utf-8');
+
+  // Clear dirty flag if present.
+  try {
+    await unlink(dirtyFlagPath());
+  } catch {
+    /* not present — fine */
+  }
+
+  return {
+    indexPath: indexPath(),
+    decisionCount: all.length,
+    recentCount: recent.length,
+  };
+}
+
+/**
+ * Read the dirty flag (returns true if INDEX.md needs regen).
+ */
+export async function isIndexDirty() {
+  try {
+    await stat(dirtyFlagPath());
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Hook entry point — called by dispatcher on SessionEnd.
+ */
+export async function handleRegenIndex({ event } = {}) {
+  const cwd = event?.cwd || process.cwd();
+  const result = await regenIndex({ cwd });
+  return {
+    exitCode: 0,
+    message: `INDEX.md regenerated (${result.recentCount} recent of ${result.decisionCount} total decisions)`,
+  };
+}

package/src/hooks-gen.js

@@ -4,14 +4,36 @@
 
 import { CREDENTIAL_PATHS } from './profiles.js';
 
+/**
+ * Detect whether `claudenv` is on PATH globally. Used to decide whether
+ * settings.json hooks should call `claudenv hook ...` directly or via `npx`.
+ *
+ * Async — but settings generation is sync today. We call this from the
+ * installer flow where we await it, then pass the resolved value in.
+ */
+export async function isGlobalInstall() {
+  try {
+    const { execFile } = await import('node:child_process');
+    const { promisify } = await import('node:util');
+    const exec = promisify(execFile);
+    await exec('which', ['claudenv']);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Generate .claude/settings.json content for a given profile.
  * @param {object} profile - Autonomy profile
  * @param {object} detected - Tech stack detection result
+ * @param {object} [opts]
+ * @param {string} [opts.claudenvCmd] - Command prefix for `claudenv hook ...` (e.g., "claudenv" or "npx claudenv")
  * @returns {string} JSON string
  */
-export function generateSettingsJson(profile, detected = {}) {
+export function generateSettingsJson(profile, detected = {}, opts = {}) {
   const settings = {};
+  const claudenvCmd = opts.claudenvCmd || 'claudenv';
 
   if (profile.allowedTools && profile.allowedTools.length > 0) {
     settings.permissions = settings.permissions || {};
@@ -46,6 +68,16 @@ export function generateSettingsJson(profile, detected = {}) {
     command: 'bash .claude/hooks/audit-log.sh',
     timeout: 10,
   };
+  const decisionsLoggerHook = {
+    type: 'command',
+    command: `${claudenvCmd} hook decisions-logger`,
+    timeout: 5,
+  };
+  const regenIndexHook = {
+    type: 'command',
+    command: `${claudenvCmd} hook regen-index`,
+    timeout: 5,
+  };
 
   settings.hooks = {
     PreToolUse: [
@@ -71,6 +103,16 @@ export function generateSettingsJson(profile, detected = {}) {
         matcher: '',
         hooks: [auditLogHook],
       },
+      {
+        matcher: 'Write',
+        hooks: [decisionsLoggerHook],
+      },
+    ],
+    SessionEnd: [
+      {
+        matcher: '.*',
+        hooks: [regenIndexHook],
+      },
     ],
   };
 

package/src/installer.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SCAFFOLD_GLOBAL = join(__dirname, '..', 'scaffold', 'global');
+const SCAFFOLD_GLOBAL_CLAUDENV = join(__dirname, '..', 'scaffold', 'global-claudenv');
 
 /**
  * Get the path to ~/.claude/
@@ -13,6 +14,14 @@ function getClaudeHome() {
   return join(homedir(), '.claude');
 }
 
+/**
+ * Get the path to ~/.claudenv/ (separate from ~/.claude/ — holds cross-project
+ * memory, canon, user preferences, and the doctor config).
+ */
+function getClaudenvHome() {
+  return join(homedir(), '.claudenv');
+}
+
 /**
  * Recursively list all files in a directory (relative paths).
  */
@@ -31,20 +40,18 @@ async function listFiles(dir, base = dir) {
 }
 
 /**
- * Install global Claude Code artifacts to ~/.claude/.
- * Copies scaffold/global/.claude/ contents into ~/.claude/.
- *
- * @param {object} [options]
- * @param {boolean} [options.force] - Overwrite existing files
- * @param {string} [options.claudeHome] - Override ~/.claude/ path (for testing)
- * @returns {Promise<{written: string[], skipped: string[]}>}
+ * Copy every file under `sourceBase` into `targetBase`, skipping existing files
+ * unless `force` is set. Returns relative paths of what was written/skipped.
  */
-export async function installGlobal(options = {}) {
-  const { force = false, claudeHome } = options;
-  const targetBase = claudeHome || getClaudeHome();
-  const sourceBase = join(SCAFFOLD_GLOBAL, '.claude');
+async function copyTree(sourceBase, targetBase, { force }) {
+  let files;
+  try {
+    files = await listFiles(sourceBase);
+  } catch (err) {
+    if (err.code === 'ENOENT') return { written: [], skipped: [] };
+    throw err;
+  }
 
-  const files = await listFiles(sourceBase);
   const written = [];
   const skipped = [];
 
@@ -52,7 +59,6 @@ export async function installGlobal(options = {}) {
     const src = join(sourceBase, relPath);
     const dest = join(targetBase, relPath);
 
-    // Check if file exists and skip unless force
     if (!force) {
       try {
         await stat(dest);
@@ -66,7 +72,6 @@ export async function installGlobal(options = {}) {
     await mkdir(dirname(dest), { recursive: true });
     await cp(src, dest);
 
-    // Make .sh files executable
     if (relPath.endsWith('.sh')) {
       const { chmod } = await import('node:fs/promises');
       await chmod(dest, 0o755);
@@ -78,6 +83,36 @@ export async function installGlobal(options = {}) {
   return { written, skipped };
 }
 
+/**
+ * Install global Claude Code artifacts to ~/.claude/ AND ~/.claudenv/.
+ * Copies scaffold/global/.claude/ → ~/.claude/ and scaffold/global-claudenv/ → ~/.claudenv/.
+ *
+ * @param {object} [options]
+ * @param {boolean} [options.force] - Overwrite existing files
+ * @param {string} [options.claudeHome] - Override ~/.claude/ path (for testing)
+ * @param {string} [options.claudenvHome] - Override ~/.claudenv/ path (for testing)
+ * @returns {Promise<{written: string[], skipped: string[], claudenvWritten: string[], claudenvSkipped: string[]}>}
+ */
+export async function installGlobal(options = {}) {
+  const { force = false, claudeHome, claudenvHome } = options;
+  const claudeTarget = claudeHome || getClaudeHome();
+  const claudenvTarget = claudenvHome || getClaudenvHome();
+
+  const claude = await copyTree(join(SCAFFOLD_GLOBAL, '.claude'), claudeTarget, { force });
+  const claudenv = await copyTree(SCAFFOLD_GLOBAL_CLAUDENV, claudenvTarget, { force });
+
+  // Ensure baseline subdirectories exist even when scaffold doesn't carry .gitkeep
+  // (decisions/ is empty by design until vibe-decisions fills it).
+  await mkdir(join(claudenvTarget, 'memories', 'decisions'), { recursive: true });
+
+  return {
+    written: claude.written,
+    skipped: claude.skipped,
+    claudenvWritten: claudenv.written,
+    claudenvSkipped: claudenv.skipped,
+  };
+}
+
 /**
  * Remove global Claude Code artifacts from ~/.claude/.
  *
@@ -95,7 +130,15 @@ export async function uninstallGlobal(options = {}) {
     join(targetBase, 'commands', 'autonomy.md'),
     join(targetBase, 'commands', 'setup-mcp.md'),
     join(targetBase, 'commands', 'improve.md'),
+    join(targetBase, 'commands', 'deeper.md'),
+    join(targetBase, 'commands', 'why.md'),
+    join(targetBase, 'commands', 'decisions.md'),
+    join(targetBase, 'commands', 'canon.md'),
+    join(targetBase, 'commands', 'just-code.md'),
+    join(targetBase, 'commands', 'add-source.md'),
     join(targetBase, 'skills', 'claudenv'),
+    join(targetBase, 'skills', 'vibe-decisions'),
+    join(targetBase, 'skills', 'source-connector'),
   ];
 
   for (const target of targets) {

package/src/loop.js

@@ -3,6 +3,8 @@ import { readFile, writeFile, mkdir, appendFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { select } from '@inquirer/prompts';
 import { createWorktree, removeWorktree, mergeWorktree, getCurrentBranch } from './worktree.js';
+import { buildSystemPromptWithMemory } from './memory-context.js';
+import { regenIndex } from './hooks/regen-index.js';
 
 // =============================================
 // Work report helpers
@@ -51,6 +53,7 @@ export function checkClaudeCli() {
  * @param {string} [options.model] - Model to use
  * @param {number} [options.budget] - Budget cap in USD
  * @param {string} [options.appendSystemPrompt] - Append to system prompt
+ * @param {object} [options.env] - Extra env vars to merge into the child process env
  * @returns {Promise<{ result: string, sessionId: string|null, usage: object|null }>}
  */
 export function spawnClaude(prompt, options = {}) {
@@ -81,6 +84,7 @@ export function spawnClaude(prompt, options = {}) {
 
     const child = spawn('claude', args, {
       cwd: options.cwd || process.cwd(),
+      env: options.env ? { ...process.env, ...options.env } : process.env,
       // stdin=inherit avoids Node.js spawn hang bug, stdout=pipe to capture JSON, stderr=pipe for rate limit detection
       stdio: ['inherit', 'pipe', 'pipe'],
     });
@@ -520,6 +524,14 @@ export async function runLoop(options = {}) {
   };
 
   // --- Shared spawn options ---
+  // appendSystemPrompt now includes:
+  //   - autonomy=law directive (from goal)
+  //   - vibe-decisions loop-mode fragment (so the skill auto-logs without pause)
+  //   - memory briefing (INDEX.md contents) if present
+  // The prompt is stable for the session; the prefix stays cache-friendly.
+  const appendedPrompt = await buildSystemPromptWithMemory(options.goal, {
+    autonomyBuilder: buildAutonomySystemPrompt,
+  });
   const spawnOpts = {
     cwd,
     trust: options.trust || false,
@@ -527,7 +539,12 @@ export async function runLoop(options = {}) {
     maxTurns: options.maxTurns || 30,
     model: options.model,
     budget: options.budget,
-    appendSystemPrompt: options.goal ? buildAutonomySystemPrompt(options.goal) : undefined,
+    appendSystemPrompt: appendedPrompt,
+    // Secondary marker for Python helpers (e.g. claudenv-memory 0.2.x) that
+    // want to detect they're being driven by `claudenv loop`. The PRIMARY
+    // mode signal stays the directive fragment in appendSystemPrompt above —
+    // env alone wouldn't be readable by the markdown skill.
+    env: { CLAUDENV_LOOP: '1' },
   };
 
   let sessionId = options.initialSessionId || null;
@@ -585,6 +602,10 @@ export async function runLoop(options = {}) {
         tokens: planResult.usage ? { in: planResult.usage.input_tokens, out: planResult.usage.output_tokens } : null,
       });
 
+      // Fallback for SessionEnd hook — regen INDEX.md so the next iteration's
+      // briefing reflects anything written during planning.
+      try { await regenIndex({ cwd }); } catch { /* best-effort */ }
+
       if (shuttingDown) {
         log.stopReason = 'interrupted';
         log.completedAt = new Date().toISOString();
@@ -773,6 +794,10 @@ export async function runLoop(options = {}) {
         tokens: iterResult.usage ? { in: iterResult.usage.input_tokens, out: iterResult.usage.output_tokens } : null,
       });
 
+      // Fallback for SessionEnd hook — regen INDEX.md from accumulated decisions
+      // so the next iteration's briefing is current.
+      try { await regenIndex({ cwd }); } catch { /* best-effort */ }
+
       // --- Convergence check ---
       if (detectConvergence(iterResult.result)) {
         console.log('\n  All improvements completed.');

package/src/memory-context.js

@@ -0,0 +1,63 @@
+/**
+ * Builds the `--append-system-prompt` payload for `claudenv loop`.
+ *
+ * Three composable fragments, joined with blank lines:
+ *
+ *   1. Autonomy=law directive from the goal (existing 1.2.x behavior)
+ *   2. Vibe-decisions loop-mode marker so the skill skips pause-and-ask
+ *   3. Memory briefing — current INDEX.md contents, capped for cache stability
+ *
+ * Cache discipline: the function is pure on its inputs (goal + file state at
+ * call time). Loop.js calls it once per iteration but with stable inputs
+ * within a session, so the appended prompt remains stable.
+ */
+
+import { readFile } from 'node:fs/promises';
+import { indexMdPath } from './memory-paths.js';
+
+const VIBE_LOOP_FRAGMENT = `## Vibe-decisions mode (loop)
+
+You are running inside \`claudenv loop\` in autonomous mode. When the
+vibe-decisions skill triggers: pick the approach, write the decision log
+immediately (Write tool to /memories/decisions/<date>-<slug>.md with the
+__VIBE_DECISION__ marker), continue with code. Do NOT pause for user
+confirmation. Do NOT ask "делать так?". The goal is law.`;
+
+const MAX_BRIEFING_CHARS = 4000;
+
+/**
+ * Build the system prompt suffix.
+ *
+ * @param {string|null} goal - The loop's --goal value (may be null)
+ * @param {object} [opts]
+ * @param {(goal: string) => string} [opts.autonomyBuilder] - Caller's autonomy prompt builder
+ * @param {boolean} [opts.includeMemoryBriefing] - Default true; false skips INDEX.md read (for tests)
+ * @returns {Promise<string|undefined>} The appended prompt, or undefined if nothing to add
+ */
+export async function buildSystemPromptWithMemory(goal, opts = {}) {
+  const parts = [];
+
+  if (goal && opts.autonomyBuilder) {
+    parts.push(opts.autonomyBuilder(goal));
+  }
+
+  // Vibe-decisions loop mode is always on inside `claudenv loop`.
+  parts.push(VIBE_LOOP_FRAGMENT);
+
+  // Memory briefing — INDEX.md if present.
+  if (opts.includeMemoryBriefing !== false) {
+    try {
+      const briefing = await readFile(indexMdPath(), 'utf-8');
+      const capped =
+        briefing.length > MAX_BRIEFING_CHARS
+          ? briefing.slice(0, MAX_BRIEFING_CHARS) + '\n…(truncated)'
+          : briefing;
+      parts.push('## Memory briefing\n\n' + capped);
+    } catch {
+      /* INDEX.md absent — first session, fine */
+    }
+  }
+
+  if (parts.length === 0) return undefined;
+  return parts.join('\n\n');
+}

package/src/memory-paths.js

@@ -0,0 +1,128 @@
+/**
+ * Shared resolvers for the claudenv memory layout + a minimal YAML frontmatter
+ * parser used by hooks, CLI commands, and the loop integration.
+ *
+ * All path getters read process.env.CLAUDENV_HOME so tests can isolate without
+ * touching the real ~/.claudenv/.
+ */
+
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { readFileSync } from 'node:fs';
+
+export function claudenvHome() {
+  return process.env.CLAUDENV_HOME || join(homedir(), '.claudenv');
+}
+
+export function memoriesDir() {
+  return join(claudenvHome(), 'memories');
+}
+
+export function globalDecisionsDir() {
+  return join(memoriesDir(), 'decisions');
+}
+
+export function canonIndexPath() {
+  return join(memoriesDir(), 'canon', 'index.yaml');
+}
+
+export function userPrefsPath() {
+  return join(memoriesDir(), 'user', 'preferences.md');
+}
+
+export function indexMdPath() {
+  return join(memoriesDir(), 'INDEX.md');
+}
+
+export function dirtyFlagPath() {
+  return join(claudenvHome(), '.index-dirty');
+}
+
+export function projectDecisionsDir(cwd) {
+  return join(cwd, '.claude', 'memories', 'decisions');
+}
+
+// --- Workspace layer (isolated per-company/context memory) ---
+
+export function workspacesDir() {
+  return join(claudenvHome(), 'workspaces');
+}
+
+export function activeWorkspaceFile() {
+  return join(claudenvHome(), 'active-workspace');
+}
+
+export function workspaceDir(id) {
+  return join(workspacesDir(), id);
+}
+
+export function workspaceManifestPath(id) {
+  return join(workspaceDir(id), 'workspace.yaml');
+}
+
+export function workspaceConnectorsDir(id) {
+  return join(workspaceDir(id), 'memories', 'connectors');
+}
+
+export function workspaceContextDir(id) {
+  return join(workspaceDir(id), 'memories', 'context');
+}
+
+/**
+ * Resolve the active workspace id. Priority: env CLAUDENV_WORKSPACE, then the
+ * pointer file ~/.claudenv/active-workspace. Returns null if none set.
+ * Intentionally does NOT scan all workspaces - isolation barrier.
+ */
+export function activeWorkspaceId() {
+  if (process.env.CLAUDENV_WORKSPACE) return process.env.CLAUDENV_WORKSPACE.trim();
+  try {
+    const id = readFileSync(activeWorkspaceFile(), 'utf-8').trim();
+    return id || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Minimal YAML frontmatter parser. Returns null when no frontmatter is present.
+ * Handles `key: value` and inline arrays `[a, b, c]`. Heavier structures fall
+ * through as raw strings — frontmatter here is intentionally flat.
+ */
+export function parseFrontmatter(text) {
+  const match = /^---\n([\s\S]*?)\n---/.exec(text);
+  if (!match) return null;
+  const result = {};
+  for (const line of match[1].split('\n')) {
+    const m = /^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)$/.exec(line);
+    if (!m) continue;
+    let value = m[2].trim();
+    if (value.startsWith('[') && value.endsWith(']')) {
+      value = value
+        .slice(1, -1)
+        .split(',')
+        .map((s) => s.trim().replace(/^['"]|['"]$/g, ''))
+        .filter(Boolean);
+    } else {
+      value = value.replace(/^['"]|['"]$/g, '');
+    }
+    result[m[1]] = value;
+  }
+  return result;
+}
+
+/**
+ * Render a flat object back into a YAML frontmatter block.
+ * Preserves array fields as inline `[a, b]`.
+ */
+export function renderFrontmatter(obj) {
+  const lines = ['---'];
+  for (const [key, value] of Object.entries(obj)) {
+    if (Array.isArray(value)) {
+      lines.push(`${key}: [${value.join(', ')}]`);
+    } else {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  lines.push('---');
+  return lines.join('\n');
+}