@kkelly-offical/kkcode 0.1.2

package/src/theme/markdown.mjs

@@ -0,0 +1,135 @@
+import { paint } from "./color.mjs"
+
+const COLORS = {
+  code: "cyan",
+  codeBlock: "#a9b7c6",
+  codeFence: "#555555",
+  heading: "white",
+  quote: "#8da3b9",
+  listMarker: "#8a8a8a"
+}
+
+function renderLine(line) {
+  const headingMatch = line.match(/^(#{1,6})\s+(.*)/)
+  if (headingMatch) {
+    const level = headingMatch[1].length
+    const content = headingMatch[2]
+    const indent = level > 1 ? "  ".repeat(level - 1) : ""
+    return `${indent}${paint(renderInline(content), COLORS.heading, { bold: level <= 2 })}`
+  }
+
+  if (line.trimStart().startsWith("> ")) {
+    const content = line.replace(/^\s*>\s?/, "")
+    return paint(`\u2502 ${renderInline(content)}`, COLORS.quote)
+  }
+
+  const ulMatch = line.match(/^(\s*)([-*+])\s+(.*)/)
+  if (ulMatch) {
+    return `${ulMatch[1]}${paint("\u2022", COLORS.listMarker)} ${renderInline(ulMatch[3])}`
+  }
+
+  const olMatch = line.match(/^(\s*)(\d+)\.\s+(.*)/)
+  if (olMatch) {
+    return `${olMatch[1]}${paint(`${olMatch[2]}.`, COLORS.listMarker)} ${renderInline(olMatch[3])}`
+  }
+
+  return renderInline(line)
+}
+
+function renderInline(text) {
+  return text
+    .replace(/`([^`]+)`/g, (_, code) => paint(code, COLORS.code))
+    .replace(/\*\*([^*]+)\*\*/g, (_, b) => paint(b, null, { bold: true }))
+    .replace(/__([^_]+)__/g, (_, b) => paint(b, null, { bold: true }))
+    .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_, i) => paint(i, null, { dim: true }))
+    .replace(/(?<!_)_([^_]+)_(?!_)/g, (_, i) => paint(i, null, { dim: true }))
+}
+
+export function renderMarkdown(text) {
+  if (!text) return ""
+  const lines = text.split("\n")
+  const out = []
+  let inCodeBlock = false
+  let codeLang = ""
+
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      if (!inCodeBlock) {
+        codeLang = line.trimStart().slice(3).trim()
+        const label = codeLang ? ` ${codeLang} ` : ""
+        out.push(paint(`\u2500\u2500\u2500${label}${"".padEnd(Math.max(0, 40 - label.length), "\u2500")}`, COLORS.codeFence))
+        inCodeBlock = true
+      } else {
+        out.push(paint("\u2500".repeat(43), COLORS.codeFence))
+        inCodeBlock = false
+        codeLang = ""
+      }
+      continue
+    }
+
+    if (inCodeBlock) {
+      out.push(paint(`  ${line}`, COLORS.codeBlock))
+      continue
+    }
+
+    out.push(renderLine(line))
+  }
+  return out.join("\n")
+}
+
+export function createStreamRenderer() {
+  let buffer = ""
+  let inCodeBlock = false
+
+  function push(chunk) {
+    buffer += chunk
+    const output = []
+
+    while (true) {
+      const idx = buffer.indexOf("\n")
+      if (idx === -1) break
+
+      const line = buffer.slice(0, idx)
+      buffer = buffer.slice(idx + 1)
+
+      if (line.trimStart().startsWith("```")) {
+        if (!inCodeBlock) {
+          const lang = line.trimStart().slice(3).trim()
+          const label = lang ? ` ${lang} ` : ""
+          output.push(paint(`\u2500\u2500\u2500${label}${"".padEnd(Math.max(0, 40 - label.length), "\u2500")}`, COLORS.codeFence) + "\n")
+          inCodeBlock = true
+        } else {
+          output.push(paint("\u2500".repeat(43), COLORS.codeFence) + "\n")
+          inCodeBlock = false
+        }
+        continue
+      }
+
+      if (inCodeBlock) {
+        output.push(paint(`  ${line}`, COLORS.codeBlock) + "\n")
+      } else {
+        output.push(renderLine(line) + "\n")
+      }
+    }
+
+    if (!inCodeBlock && buffer.length > 0 && !buffer.startsWith("```")) {
+      const partial = renderInline(buffer)
+      buffer = ""
+      output.push(partial)
+    }
+
+    return output.join("")
+  }
+
+  function flush() {
+    if (!buffer) return ""
+    const remaining = inCodeBlock
+      ? paint(`  ${buffer}`, COLORS.codeBlock)
+      : renderLine(buffer)
+    buffer = ""
+    inCodeBlock = false
+    return remaining
+  }
+
+  return { push, flush }
+}

package/src/theme/schema.mjs

@@ -0,0 +1,45 @@
+const REQUIRED_GROUPS = ["base", "semantic", "modes", "components"]
+const MODE_KEYS = ["ask", "plan", "agent", "longagent"]
+const HEX_RE = /^#([A-Fa-f0-9]{6})$/
+
+function validateColor(value, path, errors) {
+  if (typeof value !== "string" || !HEX_RE.test(value)) {
+    errors.push(`${path} must be a hex color like #00ff00`)
+  }
+}
+
+export function validateTheme(theme) {
+  const errors = []
+  if (!theme || typeof theme !== "object" || Array.isArray(theme)) {
+    return { valid: false, errors: ["theme must be an object"] }
+  }
+  if (typeof theme.name !== "string" || theme.name.trim().length === 0) {
+    errors.push("name must be a non-empty string")
+  }
+  for (const group of REQUIRED_GROUPS) {
+    if (!theme[group] || typeof theme[group] !== "object" || Array.isArray(theme[group])) {
+      errors.push(`${group} must be an object`)
+    }
+  }
+  if (theme.base) {
+    for (const key of ["bg", "fg", "muted", "border", "accent"]) {
+      validateColor(theme.base[key], `base.${key}`, errors)
+    }
+  }
+  if (theme.semantic) {
+    for (const key of ["info", "warn", "error", "success"]) {
+      validateColor(theme.semantic[key], `semantic.${key}`, errors)
+    }
+  }
+  if (theme.components) {
+    for (const key of ["panel", "header", "footer", "diff_add", "diff_del"]) {
+      validateColor(theme.components[key], `components.${key}`, errors)
+    }
+  }
+  if (theme.modes) {
+    for (const key of MODE_KEYS) {
+      validateColor(theme.modes[key], `modes.${key}`, errors)
+    }
+  }
+  return { valid: errors.length === 0, errors }
+}

package/src/theme/status-bar.mjs

@@ -0,0 +1,158 @@
+import { paint } from "./color.mjs"
+
+function formatNumber(value) {
+  return Intl.NumberFormat("en-US").format(Math.round(value))
+}
+
+function formatCost(amount) {
+  if (amount === null || amount === undefined) return "unknown"
+  return `$${amount.toFixed(4)}`
+}
+
+function permissionColor(permission, theme) {
+  switch (permission) {
+    case "allow": return theme.semantic.success || theme.semantic.info
+    case "deny": return theme.semantic.error || theme.semantic.warn
+    case "ask":
+    default:
+      return theme.semantic.info
+  }
+}
+
+function contrastText(hex, dark = "#111111", light = "#f7f7f7") {
+  if (!/^#([A-Fa-f0-9]{6})$/.test(String(hex || ""))) return light
+  const raw = hex.replace("#", "")
+  const r = parseInt(raw.slice(0, 2), 16)
+  const g = parseInt(raw.slice(2, 4), 16)
+  const b = parseInt(raw.slice(4, 6), 16)
+  const y = 0.2126 * r + 0.7152 * g + 0.0722 * b
+  return y > 150 ? dark : light
+}
+
+function badge(text, fg, bg, options = {}) {
+  return paint(` ${text} `, fg, { bg, bold: options.bold !== false })
+}
+
+function clipModel(model, maxLen) {
+  const value = String(model || "")
+  if (value.length <= maxLen) return value
+  if (maxLen < 10) return value.slice(0, maxLen)
+  return `${value.slice(0, Math.max(4, maxLen - 4))}...`
+}
+
+export function renderStatusBar({
+  mode,
+  model,
+  permission,
+  tokenMeter,
+  aggregation = ["turn", "session", "global"],
+  cost,
+  savings = 0,
+  showCost = true,
+  showTokenMeter = true,
+  contextMeter = null,
+  theme,
+  layout = "compact",
+  longagentState = null,
+  memoryLoaded = false
+}) {
+  const width = Number(process.stdout.columns || 120)
+  const dense = width < 110
+  const tight = width < 86
+  const modelLabel = clipModel(model, tight ? 18 : dense ? 28 : 44)
+
+  const segments = []
+  const modeBg = theme.modes[mode] || theme.base.accent
+  segments.push(badge(mode.toUpperCase(), contrastText(modeBg), modeBg))
+  segments.push(badge(`MODEL ${modelLabel}`, theme.base.fg, theme.components.panel || theme.base.border, { bold: false }))
+
+  if (showTokenMeter && tokenMeter) {
+    const t = tokenMeter.turn
+    const s = tokenMeter.session
+    const g = tokenMeter.global
+    const tokenSegments = []
+    if (aggregation.includes("turn")) tokenSegments.push(`T:${formatNumber(t.input + t.output)}`)
+    if (!tight && aggregation.includes("session")) tokenSegments.push(`S:${formatNumber(s.input + s.output)}`)
+    if (!dense && aggregation.includes("global")) tokenSegments.push(`G:${formatNumber(g.input + g.output)}`)
+    const tokenText = `TOKENS ${tokenSegments.join(" ")}${tokenMeter.estimated ? " ~" : ""}`
+    segments.push(
+      badge(tokenText, theme.base.fg, "#2d3748", { bold: false })
+    )
+  }
+  if (showCost) {
+    const savingsStr = savings > 0 ? ` ↓${formatCost(savings)}` : ""
+    segments.push(badge(`COST ${formatCost(cost)}${savingsStr}`, contrastText(theme.semantic.warn), theme.semantic.warn, { bold: false }))
+  }
+  if (contextMeter && Number.isFinite(contextMeter.percent)) {
+    const pct = Math.max(0, Math.min(100, Math.round(contextMeter.percent)))
+    const ctxBg = pct >= 85
+      ? theme.semantic.error
+      : pct >= 70
+        ? theme.semantic.warn
+        : theme.semantic.info
+    let suffix = ""
+    if (contextMeter.cacheRead > 0 || contextMeter.cacheWrite > 0) {
+      const total = (contextMeter.cacheRead || 0) + (contextMeter.cacheWrite || 0) + (contextMeter.inputUncached || 0)
+      const hitPct = total > 0 ? Math.round((contextMeter.cacheRead || 0) / total * 100) : 0
+      suffix = ` Cache:${hitPct}%`
+    }
+    const text = tight ? `CTX ${pct}%` : `CONTEXT ${pct}%${suffix}`
+    segments.push(badge(text, contrastText(ctxBg), ctxBg, { bold: false }))
+  }
+  if (memoryLoaded && !tight) {
+    segments.push(badge("MEM", contrastText(theme.semantic.info), theme.semantic.info, { bold: false }))
+  }
+  const permBg = permissionColor(permission, theme)
+  segments.push(badge(`PERMISSION ${permission.toUpperCase()}`, contrastText(permBg), permBg, { bold: false }))
+  if (longagentState && mode === "longagent") {
+    const parts = []
+    if (longagentState.currentStageId) {
+      parts.push(`STG:${longagentState.currentStageId}`)
+    } else if (Number.isFinite(longagentState.stageIndex) && Number.isFinite(longagentState.stageCount) && longagentState.stageCount > 0) {
+      parts.push(`STG:${longagentState.stageIndex + 1}/${longagentState.stageCount}`)
+    }
+    if (longagentState.stageProgress?.total) {
+      parts.push(`TSK:${longagentState.stageProgress.done || 0}/${longagentState.stageProgress.total}`)
+    }
+    if (Number.isFinite(longagentState.remainingFilesCount)) {
+      parts.push(`REM:${longagentState.remainingFilesCount}`)
+    }
+    if (longagentState.phase) {
+      parts.push(`P:${longagentState.phase}`)
+    }
+    if (longagentState.currentGate) {
+      parts.push(`G:${longagentState.currentGate}`)
+    }
+    if (longagentState.iterations !== undefined) {
+      const iter = longagentState.maxIterations
+        ? `${longagentState.iterations}/${longagentState.maxIterations}`
+        : String(longagentState.iterations)
+      parts.push(`I:${iter}`)
+    }
+    if (!tight && longagentState.progress?.percentage !== null && longagentState.progress?.percentage !== undefined) {
+      const pct = longagentState.progress.percentage
+      const barW = dense ? 8 : 14
+      const filled = Math.round(barW * pct / 100)
+      parts.push(`${"█".repeat(filled)}${"░".repeat(barW - filled)} ${pct}%`)
+    }
+    if (!dense && longagentState.elapsed !== undefined) {
+      const m = Math.floor(longagentState.elapsed / 60)
+      const s = longagentState.elapsed % 60
+      parts.push(`${m}m${s}s`)
+    }
+    if (!tight && Array.isArray(longagentState.lastGateFailures) && longagentState.lastGateFailures.length) {
+      parts.push(`Fail`)
+    }
+    if (!tight && typeof longagentState.recoveryCount === "number" && longagentState.recoveryCount > 0) {
+      parts.push(`R:${longagentState.recoveryCount}`)
+    }
+    if (parts.length) {
+      segments.push(badge(`LONG ${parts.join(" ")}`, contrastText(theme.semantic.success), theme.semantic.success, { bold: false }))
+    }
+  }
+
+  if (layout === "comfortable") {
+    return segments.join("  ")
+  }
+  return segments.join(" ")
+}

package/src/tool/audit-wrapper.mjs

@@ -0,0 +1,38 @@
+import { appendAuditEntry } from "../storage/audit-store.mjs"
+
+export async function withAudit({ sessionId, turnId, toolName, args, run }) {
+  const startedAt = Date.now()
+  await appendAuditEntry({
+    type: "tool.start",
+    sessionId,
+    turnId,
+    tool: toolName,
+    args
+  })
+  try {
+    const result = await run()
+    await appendAuditEntry({
+      type: "tool.finish",
+      sessionId,
+      turnId,
+      tool: toolName,
+      durationMs: Date.now() - startedAt,
+      ok: result?.status !== "error" && result?.status !== "cancelled",
+      status: result?.status,
+      output: result?.output?.slice(0, 2000) || ""
+    })
+    return result
+  } catch (error) {
+    await appendAuditEntry({
+      type: "tool.error",
+      sessionId,
+      turnId,
+      tool: toolName,
+      durationMs: Date.now() - startedAt,
+      ok: false,
+      status: "error",
+      error: error.message
+    })
+    throw error
+  }
+}

package/src/tool/edit-transaction.mjs

@@ -0,0 +1,126 @@
+import path from "node:path"
+import { readFile, writeFile, rename, unlink, mkdir } from "node:fs/promises"
+
+function tmpPath(target) {
+  return `${target}.kkcode.tmp`
+}
+
+function backupPath(target) {
+  return `${target}.kkcode.bak`
+}
+
+/**
+ * Count added/removed lines between two text snippets using LCS.
+ * For snippets under 500 lines, uses O(m*n) DP. For larger texts, falls back to simple line-count diff.
+ */
+export function diffLineCount(oldText, newText) {
+  const oldLines = String(oldText || "").split(/\r?\n/)
+  const newLines = String(newText || "").split(/\r?\n/)
+  const m = oldLines.length
+  const n = newLines.length
+
+  // Fast path: identical
+  if (oldText === newText) return { added: 0, removed: 0 }
+
+  // For large texts, fall back to simple counting to avoid O(m*n) blowup
+  if (m > 500 || n > 500) {
+    // Build a set of old lines with counts
+    const oldCounts = new Map()
+    for (const line of oldLines) oldCounts.set(line, (oldCounts.get(line) || 0) + 1)
+    const newCounts = new Map()
+    for (const line of newLines) newCounts.set(line, (newCounts.get(line) || 0) + 1)
+    let common = 0
+    for (const [line, count] of oldCounts) {
+      common += Math.min(count, newCounts.get(line) || 0)
+    }
+    return { added: n - common, removed: m - common }
+  }
+
+  // LCS via DP
+  const dp = Array.from({ length: m + 1 }, () => new Uint16Array(n + 1))
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (oldLines[i - 1] === newLines[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1])
+      }
+    }
+  }
+  const common = dp[m][n]
+  return { added: n - common, removed: m - common }
+}
+
+export async function atomicWriteFile(target, content) {
+  const dir = path.dirname(target)
+  await mkdir(dir, { recursive: true })
+  const tmp = tmpPath(target)
+  const bak = backupPath(target)
+  let hadOriginal = false
+  try {
+    const existing = await readFile(target, "utf8")
+    hadOriginal = true
+    await writeFile(bak, existing, "utf8")
+  } catch {
+    hadOriginal = false
+  }
+
+  try {
+    await writeFile(tmp, content, "utf8")
+    await rename(tmp, target)
+    if (hadOriginal) {
+      await unlink(bak).catch(() => {})
+    }
+  } catch (error) {
+    if (hadOriginal) {
+      const bakContent = await readFile(bak, "utf8").catch(() => null)
+      if (bakContent !== null) {
+        await writeFile(target, bakContent, "utf8").catch(() => {})
+      }
+      await unlink(bak).catch(() => {})
+    }
+    await unlink(tmp).catch(() => {})
+    throw error
+  }
+}
+
+export async function replaceInFileTransactional(target, before, after) {
+  const absolute = path.resolve(target)
+  const content = await readFile(absolute, "utf8")
+  const matches = content.split(before).length - 1
+  if (matches <= 0) {
+    return { ok: false, output: "no match", matches: 0, addedLines: 0, removedLines: 0 }
+  }
+  if (matches > 1) {
+    return { ok: false, output: `ambiguous: found ${matches} occurrences, expected exactly 1. Provide more surrounding context to match uniquely.`, matches, addedLines: 0, removedLines: 0 }
+  }
+  const next = content.replace(before, after)
+  await atomicWriteFile(absolute, next)
+  const diff = diffLineCount(before, after)
+  return {
+    ok: true,
+    output: `replaced 1 occurrence`,
+    matches: 1,
+    addedLines: diff.added,
+    removedLines: diff.removed
+  }
+}
+
+export async function replaceAllInFileTransactional(target, before, after) {
+  const absolute = path.resolve(target)
+  const content = await readFile(absolute, "utf8")
+  const matches = content.split(before).length - 1
+  if (matches <= 0) {
+    return { ok: false, output: "no match", matches: 0, addedLines: 0, removedLines: 0 }
+  }
+  const next = content.replaceAll(before, after)
+  await atomicWriteFile(absolute, next)
+  const diff = diffLineCount(content, next)
+  return {
+    ok: true,
+    output: `replaced ${matches} occurrence(s)`,
+    matches,
+    addedLines: diff.added,
+    removedLines: diff.removed
+  }
+}

package/src/tool/executor.mjs

@@ -0,0 +1,109 @@
+import { makeToolResult } from "../core/types.mjs"
+import { EventBus } from "../core/events.mjs"
+import { EVENT_TYPES } from "../core/constants.mjs"
+import { withAudit } from "./audit-wrapper.mjs"
+
+export async function executeTool({ tool, args, sessionId, turnId, context, signal = null }) {
+  return withAudit({
+    sessionId,
+    turnId,
+    toolName: tool.name,
+    args,
+    run: async () => {
+      const startedAt = Date.now()
+      await EventBus.emit({
+        type: EVENT_TYPES.TOOL_START,
+        sessionId,
+        turnId,
+        payload: {
+          tool: tool.name,
+          args
+        }
+      })
+
+      try {
+        if (signal?.aborted) {
+          const cancelled = makeToolResult({
+            name: tool.name,
+            status: "cancelled",
+            output: "tool cancelled before execution",
+            durationMs: Date.now() - startedAt
+          })
+          await EventBus.emit({
+            type: EVENT_TYPES.TOOL_ERROR,
+            sessionId,
+            turnId,
+            payload: {
+              tool: tool.name,
+              status: cancelled.status,
+              output: cancelled.output,
+              args,
+              durationMs: cancelled.durationMs
+            }
+          })
+          return cancelled
+        }
+
+        const raw = await tool.execute(args || {}, context)
+        let output = ""
+        let metadata = {}
+        if (typeof raw === "string") {
+          output = raw
+        } else if (raw && typeof raw === "object") {
+          if (typeof raw.output === "string") {
+            output = raw.output
+          } else {
+            output = JSON.stringify(raw, null, 2)
+          }
+          if (raw.metadata && typeof raw.metadata === "object") {
+            metadata = raw.metadata
+          }
+        } else {
+          output = String(raw ?? "")
+        }
+        const result = makeToolResult({
+          name: tool.name,
+          status: "completed",
+          output,
+          durationMs: Date.now() - startedAt,
+          metadata
+        })
+        await EventBus.emit({
+          type: EVENT_TYPES.TOOL_FINISH,
+          sessionId,
+          turnId,
+          payload: {
+            tool: tool.name,
+            status: result.status,
+            args,
+            output: String(output || "").slice(0, 500),
+            durationMs: result.durationMs
+          }
+        })
+        return result
+      } catch (error) {
+        const errorMessage = error?.message || String(error)
+        const result = makeToolResult({
+          name: tool.name,
+          status: "error",
+          output: errorMessage,
+          error: errorMessage,
+          durationMs: Date.now() - startedAt
+        })
+        await EventBus.emit({
+          type: EVENT_TYPES.TOOL_ERROR,
+          sessionId,
+          turnId,
+          payload: {
+            tool: tool.name,
+            status: result.status,
+            error: result.error,
+            args,
+            durationMs: result.durationMs
+          }
+        })
+        return result
+      }
+    }
+  })
+}

package/src/tool/file-lock-manager.mjs

@@ -0,0 +1,85 @@
+import path from "node:path"
+import { createHash } from "node:crypto"
+import { mkdir, open, unlink, writeFile } from "node:fs/promises"
+import { userRootDir } from "../storage/paths.mjs"
+
+const LOCK_POLL_MS = 80
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function lockDir() {
+  return path.join(userRootDir(), "locks")
+}
+
+function lockFilePath(targetPath) {
+  const absolute = path.resolve(targetPath)
+  const hash = createHash("sha1").update(absolute).digest("hex")
+  return path.join(lockDir(), `${hash}.lock`)
+}
+
+async function ensureLockDir() {
+  await mkdir(lockDir(), { recursive: true })
+}
+
+export async function acquireFileLock({
+  targetPath,
+  owner = "unknown",
+  waitTimeoutMs = 120000
+}) {
+  await ensureLockDir()
+  const lockFile = lockFilePath(targetPath)
+  const started = Date.now()
+  while (Date.now() - started <= waitTimeoutMs) {
+    try {
+      const fd = await open(lockFile, "wx")
+      const metadata = {
+        owner,
+        pid: process.pid,
+        targetPath: path.resolve(targetPath),
+        acquiredAt: Date.now()
+      }
+      await fd.writeFile(JSON.stringify(metadata, null, 2), "utf8")
+      await fd.close()
+      return {
+        lockFile,
+        owner,
+        acquiredAt: metadata.acquiredAt
+      }
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error
+      await sleep(LOCK_POLL_MS)
+    }
+  }
+  const err = new Error(`file lock timeout: ${targetPath}`)
+  err.code = "LOCK_TIMEOUT"
+  throw err
+}
+
+export async function releaseFileLock(lockHandle) {
+  if (!lockHandle?.lockFile) return
+  await unlink(lockHandle.lockFile).catch(() => {})
+}
+
+export async function withFileLock({
+  targetPath,
+  owner = "unknown",
+  waitTimeoutMs = 120000,
+  run
+}) {
+  const lock = await acquireFileLock({ targetPath, owner, waitTimeoutMs })
+  try {
+    return await run()
+  } finally {
+    await releaseFileLock(lock)
+  }
+}
+
+export async function writeLockDebug(targetPath, owner = "unknown") {
+  await ensureLockDir()
+  const infoFile = `${lockFilePath(targetPath)}.meta`
+  await writeFile(infoFile, JSON.stringify({ owner, at: Date.now() }, null, 2), "utf8")
+  return infoFile
+}
+