@golba98/codexa 1.0.1

package/src/core/executables/geminiExecutable.test.ts

@@ -0,0 +1,116 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { ChildProcess } from "node:child_process";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { buildGeminiSpawnSpec, resetGeminiExecutableCacheForTests, resolveGeminiExecutable } from "./geminiExecutable.js";
+import { runCommand, type CommandResult } from "../process/CommandRunner.js";
+
+function commandResult(overrides: Partial<CommandResult>): CommandResult {
+  return {
+    status: "completed",
+    exitCode: 0,
+    signal: null,
+    stdout: "",
+    stderr: "",
+    startedAt: 0,
+    endedAt: 0,
+    durationMs: 0,
+    userMessage: "Command completed.",
+    ...overrides,
+  };
+}
+
+function mockRunCommand(onCall: (spec: Parameters<typeof runCommand>[0]) => CommandResult): typeof runCommand {
+  return ((spec) => ({
+    child: null as unknown as ChildProcess,
+    result: Promise.resolve(onCall(spec)),
+    cancel: () => undefined,
+  })) as typeof runCommand;
+}
+
+async function withEnv<T>(env: Partial<NodeJS.ProcessEnv>, callback: () => Promise<T>): Promise<T> {
+  const originalExecutable = process.env.GEMINI_EXECUTABLE;
+  const originalCliPath = process.env.GEMINI_CLI_PATH;
+  const originalAppData = process.env.APPDATA;
+  try {
+    if ("GEMINI_EXECUTABLE" in env) process.env.GEMINI_EXECUTABLE = env.GEMINI_EXECUTABLE;
+    else delete process.env.GEMINI_EXECUTABLE;
+    if ("GEMINI_CLI_PATH" in env) process.env.GEMINI_CLI_PATH = env.GEMINI_CLI_PATH;
+    else delete process.env.GEMINI_CLI_PATH;
+    if ("APPDATA" in env) process.env.APPDATA = env.APPDATA;
+    resetGeminiExecutableCacheForTests();
+    return await callback();
+  } finally {
+    if (originalExecutable === undefined) delete process.env.GEMINI_EXECUTABLE;
+    else process.env.GEMINI_EXECUTABLE = originalExecutable;
+    if (originalCliPath === undefined) delete process.env.GEMINI_CLI_PATH;
+    else process.env.GEMINI_CLI_PATH = originalCliPath;
+    if (originalAppData === undefined) delete process.env.APPDATA;
+    else process.env.APPDATA = originalAppData;
+    resetGeminiExecutableCacheForTests();
+  }
+}
+
+test("Gemini resolver: env GEMINI_EXECUTABLE wins over PATH", async () => {
+  await withEnv({ GEMINI_EXECUTABLE: "env-gemini.cmd" }, async () => {
+    let whereCalled = false;
+    const resolved = await resolveGeminiExecutable({
+      runCommandImpl: mockRunCommand((spec) => {
+        if (spec.executable === "where.exe") whereCalled = true;
+        return commandResult({ stdout: "C:\\Tools\\gemini.cmd\n" });
+      }),
+    });
+
+    assert.equal(resolved, "env-gemini.cmd");
+    assert.equal(whereCalled, false);
+  });
+});
+
+test("Gemini resolver: APPDATA npm shim fallback works", async () => {
+  if (process.platform !== "win32") return;
+  const tempRoot = join(tmpdir(), `codexa-gemini-${Date.now()}`);
+  const npmDir = join(tempRoot, "npm");
+  const shim = join(npmDir, "gemini.cmd");
+  mkdirSync(npmDir, { recursive: true });
+  writeFileSync(shim, "@echo off\r\n", "utf-8");
+
+  try {
+    await withEnv({ APPDATA: tempRoot }, async () => {
+      const resolved = await resolveGeminiExecutable({
+        runCommandImpl: mockRunCommand(() => commandResult({ status: "failed", exitCode: 1 })),
+      });
+      assert.equal(resolved, shim);
+    });
+  } finally {
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test("Gemini resolver: PowerShell function text is not accepted as executable path", async () => {
+  if (process.platform !== "win32") return;
+  await withEnv({}, async () => {
+    const tempRoot = join(tmpdir(), `codexa-gemini-real-${Date.now()}`);
+    const npmDir = join(tempRoot, "npm");
+    const shim = join(npmDir, "gemini.cmd");
+    mkdirSync(npmDir, { recursive: true });
+    writeFileSync(shim, "@echo off\r\n", "utf-8");
+    process.env.APPDATA = tempRoot;
+    try {
+      const resolved = await resolveGeminiExecutable({
+        runCommandImpl: mockRunCommand(() => commandResult({ stdout: "function gemini { param($p) }\n" })),
+      });
+      assert.equal(resolved, shim);
+    } finally {
+      rmSync(tempRoot, { recursive: true, force: true });
+    }
+  });
+});
+
+test("Gemini spawn spec bypasses PowerShell and targets the resolved executable", () => {
+  const spec = buildGeminiSpawnSpec("C:\\Users\\Example\\AppData\\Roaming\\npm\\gemini.cmd", ["-p", "Respond with READY only."]);
+  assert.equal(spec.executable, "C:\\Users\\Example\\AppData\\Roaming\\npm\\gemini.cmd");
+  assert.deepEqual(spec.args, ["-p", "Respond with READY only."]);
+  assert.equal(spec.shell, undefined);
+});

package/src/core/executables/geminiExecutable.ts

@@ -0,0 +1,78 @@
+import { join } from "path";
+import { runCommand } from "../process/CommandRunner.js";
+import { resolveExecutable } from "./executableResolver.js";
+
+type CommandRunner = typeof runCommand;
+
+let cachedExecutable: string | null = null;
+
+export function resetGeminiExecutableCacheForTests(): void {
+  cachedExecutable = null;
+}
+
+/**
+ * Returns the resolved Gemini CLI executable (full path or bare name).
+ *
+ * Priority:
+ *   1. Configured path override (geminiCommandPath)
+ *   2. GEMINI_EXECUTABLE or GEMINI_CLI_PATH env var
+ *   3. Windows PATH lookup for real files: gemini.exe, gemini.cmd, gemini.bat, gemini
+ *   4. Windows where.exe gemini fallback
+ *   5. Common npm/global locations on Windows
+ */
+export async function resolveGeminiExecutable(options?: {
+  runCommandImpl?: CommandRunner;
+  cwd?: string;
+  configuredPath?: string | null;
+}): Promise<string> {
+  if (!options?.configuredPath && !options?.runCommandImpl && cachedExecutable !== null) {
+    return cachedExecutable;
+  }
+
+  const knownPathDirectories: string[] = [];
+  const userProfile = process.env.USERPROFILE;
+  const appData = process.env.APPDATA;
+  const localAppData = process.env.LOCALAPPDATA;
+
+  if (process.platform === "win32") {
+    if (appData) {
+      knownPathDirectories.push(join(appData, "npm"));
+    }
+    if (localAppData) {
+      knownPathDirectories.push(join(localAppData, "Programs", "nodejs"));
+    }
+  }
+
+  if (userProfile) {
+    knownPathDirectories.push(join(userProfile, ".local", "bin"));
+    knownPathDirectories.push(join(userProfile, "bin"));
+  }
+
+  const result = await resolveExecutable({
+    runCommandImpl: options?.runCommandImpl,
+    cwd: options?.cwd,
+    configuredPath: options?.configuredPath,
+    envOverrides: ["GEMINI_EXECUTABLE", "GEMINI_CLI_PATH"],
+    commandNames: ["gemini.exe", "gemini.cmd", "gemini.bat", "gemini"],
+    knownPathDirectories,
+    knownFilePaths: [],
+    label: "gemini",
+    allowBareFallback: process.platform !== "win32",
+    requireResolvedFile: true,
+  });
+
+  if (!options?.configuredPath && !options?.runCommandImpl) {
+    cachedExecutable = result;
+  }
+  return result;
+}
+
+/**
+ * Builds the spawn spec for a resolved Gemini executable.
+ */
+export function buildGeminiSpawnSpec(
+  executable: string,
+  args: string[],
+): { executable: string; args: string[]; shell?: boolean } {
+  return { executable, args };
+}

package/src/core/executables/pathSanityScan.test.ts

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+function collectTsFiles(dir: string): string[] {
+  const result: string[] = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      result.push(...collectTsFiles(full));
+    } else if (full.endsWith(".ts")) {
+      result.push(full);
+    }
+  }
+  return result;
+}
+
+const SRC_ROOT = join(import.meta.dirname, "../../..");
+
+// Guard against personal user-specific paths appearing in source.
+// Patterns are split across array entries to prevent THIS file from matching itself.
+const BANNED_FRAGMENTS: Array<[string, string]> = [
+  ["C", ":\\\\Users\\\\jorda"],
+  ["C", ":/Users/jorda"],
+];
+
+test("no source files contain personal hardcoded user paths", { timeout: 30_000 }, () => {
+  const patterns = BANNED_FRAGMENTS.map(([a, b]) => new RegExp(a + b));
+  const files = collectTsFiles(SRC_ROOT);
+  const violations: string[] = [];
+
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    for (const pattern of patterns) {
+      if (pattern.test(content)) {
+        violations.push(`${file}: matches ${pattern}`);
+      }
+    }
+  }
+
+  assert.deepEqual(
+    violations,
+    [],
+    `Personal hardcoded user paths found in source:\n${violations.join("\n")}`,
+  );
+});

package/src/core/githubDiagnostics.test.ts

@@ -0,0 +1,92 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { 
+  parseRepoIdentity, 
+  classifyDiagnostics, 
+  type DiagnosticResult, 
+  type RepoIdentity 
+} from "./githubDiagnostics.js";
+
+test("parseRepoIdentity: handles various GitHub URL formats", () => {
+  const cases = [
+    {
+      url: "https://github.com/owner/repo.git",
+      expected: { owner: "owner", repo: "repo", provider: "github" }
+    },
+    {
+      url: "git@github.com:owner/repo.git",
+      expected: { owner: "owner", repo: "repo", provider: "github" }
+    },
+    {
+      url: "https://github.com/owner/repo",
+      expected: { owner: "owner", repo: "repo", provider: "github" }
+    },
+    {
+      url: "ssh://git@github.com/owner/repo.git",
+      expected: { owner: "owner", repo: "repo", provider: "github" }
+    }
+  ];
+
+  for (const { url, expected } of cases) {
+    const result = parseRepoIdentity(url);
+    assert.ok(result);
+    assert.equal(result.owner, expected.owner);
+    assert.equal(result.repo, expected.repo);
+    assert.equal(result.provider, expected.provider);
+  }
+});
+
+test("parseRepoIdentity: handles missing or non-GitHub origins", () => {
+  assert.equal(parseRepoIdentity(null), null);
+  assert.equal(parseRepoIdentity(""), null);
+  
+  const other = parseRepoIdentity("https://gitlab.com/owner/repo.git");
+  assert.ok(other);
+  assert.equal(other.provider, "other");
+});
+
+test("classifyDiagnostics: handles all status combinations", () => {
+  const repo: RepoIdentity = { owner: "o", repo: "r", provider: "github", remoteUrl: "..." };
+  
+  const pass: DiagnosticResult = { path: "p", status: "PASS", evidence: "e", blocker: null, recommendedUse: false };
+  const fail: DiagnosticResult = { path: "p", status: "FAIL", evidence: "e", blocker: "b", recommendedUse: false };
+  const partial: DiagnosticResult = { path: "p", status: "PARTIAL", evidence: "e", blocker: "b", recommendedUse: false };
+
+  // 1. All PASS -> Local Git + GH CLI
+  assert.equal(
+    classifyDiagnostics(repo, pass, pass, pass, fail),
+    "Local Git + GH CLI"
+  );
+
+  // 2. GH CLI missing but connector OK -> Connector-only
+  assert.equal(
+    classifyDiagnostics(repo, fail, pass, pass, pass),
+    "Local Git + connector PR creation"
+  );
+
+  // 3. .git write fails but connector OK -> Connector-only
+  assert.equal(
+    classifyDiagnostics(repo, pass, pass, fail, pass),
+    "Connector-only"
+  );
+
+  // 4. Connector read OK but write unknown (treated as PASS if not auth error)
+  assert.equal(
+    classifyDiagnostics(repo, fail, fail, fail, pass),
+    "Connector-only"
+  );
+
+  // 5. Connector permission rejected
+  const connectorRejected: DiagnosticResult = { path: "p", status: "PARTIAL", evidence: "e", blocker: "auth error", recommendedUse: false };
+  assert.equal(
+    classifyDiagnostics(repo, fail, fail, fail, connectorRejected),
+    "Cannot publish yet"
+  );
+
+  // 6. Non-GitHub repo
+  const otherRepo: RepoIdentity = { owner: "", repo: "", provider: "other", remoteUrl: "..." };
+  assert.equal(
+    classifyDiagnostics(otherRepo, pass, pass, pass, pass),
+    "Cannot publish yet"
+  );
+});

package/src/core/githubDiagnostics.ts

@@ -0,0 +1,222 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+export interface RepoIdentity {
+  owner: string;
+  repo: string;
+  provider: "github" | "other";
+  remoteUrl: string;
+}
+
+export interface DiagnosticResult {
+  path: string;
+  status: "PASS" | "FAIL" | "PARTIAL";
+  evidence: string;
+  blocker: string | null;
+  recommendedUse: boolean;
+}
+
+export interface DiagnosticsReport {
+  repo: RepoIdentity | null;
+  defaultBranch: string | null;
+  ghCliUser: string | null;
+  connectorUser: string | null;
+  paths: {
+    ghCli: DiagnosticResult;
+    localGit: DiagnosticResult;
+    localGitWrite: DiagnosticResult;
+    connector: DiagnosticResult;
+  };
+  recommendedFlow:
+    | "Local Git + GH CLI"
+    | "Local Git + connector PR creation"
+    | "Connector-only"
+    | "Cannot publish yet";
+}
+
+export function parseRepoIdentity(remoteUrl: string | undefined | null): RepoIdentity | null {
+  if (!remoteUrl) return null;
+
+  const url = remoteUrl.trim();
+
+  // HTTPS: https://github.com/owner/repo.git or https://github.com/owner/repo
+  const httpsMatch = url.match(/^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/.]+?)(?:\.git)?\/?$/i);
+  if (httpsMatch) {
+    return {
+      owner: httpsMatch[1],
+      repo: httpsMatch[2],
+      provider: "github",
+      remoteUrl: url,
+    };
+  }
+
+  // SSH: git@github.com:owner/repo.git or ssh://git@github.com/owner/repo.git
+  const sshMatch = url.match(/^(?:ssh:\/\/)?git@github\.com[:\/]([^/]+)\/([^/.]+?)(?:\.git)?\/?$/i);
+  if (sshMatch) {
+    return {
+      owner: sshMatch[1],
+      repo: sshMatch[2],
+      provider: "github",
+      remoteUrl: url,
+    };
+  }
+
+  return {
+    owner: "",
+    repo: "",
+    provider: "other",
+    remoteUrl: url,
+  };
+}
+
+export function getLocalGitRemoteUrl(): string | null {
+  try {
+    return execSync("git remote get-url origin", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+export function checkGhCli(): DiagnosticResult {
+  const result: DiagnosticResult = {
+    path: "GH CLI",
+    status: "FAIL",
+    evidence: "",
+    blocker: null,
+    recommendedUse: false,
+  };
+
+  try {
+    const version = execSync("gh --version", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).split("\n")[0];
+    result.evidence = version ?? "Unknown version";
+  } catch {
+    result.blocker = "gh CLI not installed or not in PATH";
+    return result;
+  }
+
+  try {
+    // gh auth status output format is not structured JSON; pattern-match on known strings.
+    const authStatus = execSync("gh auth status", { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    result.evidence += " | Authenticated";
+    if (authStatus.includes("Token scopes")) {
+      const scopes = authStatus.match(/Token scopes: (.*)/)?.[1];
+      if (scopes && !scopes.includes("repo")) {
+        result.status = "PARTIAL";
+        result.blocker = "Token missing 'repo' scope";
+      } else {
+        result.status = "PASS";
+      }
+    } else {
+      result.status = "PASS";
+    }
+  } catch {
+    result.blocker = "Not logged in to GitHub CLI";
+  }
+
+  return result;
+}
+
+export function checkLocalGitRemote(): DiagnosticResult {
+  const result: DiagnosticResult = {
+    path: "Local git remote",
+    status: "FAIL",
+    evidence: "",
+    blocker: null,
+    recommendedUse: false,
+  };
+
+  try {
+    const remote = execSync("git remote -v", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).split("\n")[0];
+    result.evidence = remote ?? "No remote found";
+
+    execSync("git ls-remote origin HEAD", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    result.status = "PASS";
+  } catch {
+    result.blocker = "Cannot reach origin remote (check connectivity or remote URL)";
+  }
+
+  return result;
+}
+
+export function checkLocalGitWrite(): DiagnosticResult {
+  const result: DiagnosticResult = {
+    path: "Local .git write",
+    status: "FAIL",
+    evidence: "",
+    blocker: null,
+    recommendedUse: false,
+  };
+
+  const indexLock = join(".git", "index.lock");
+  if (existsSync(indexLock)) {
+    result.blocker = ".git/index.lock exists (git process might be running)";
+    return result;
+  }
+
+  try {
+    execSync("git update-ref refs/heads/codexa-diagnostic-lock-test HEAD", { stdio: "ignore" });
+    execSync("git update-ref -d refs/heads/codexa-diagnostic-lock-test", { stdio: "ignore" });
+    result.status = "PASS";
+    result.evidence = "Can create/delete refs";
+  } catch (error) {
+    result.blocker = "Failed to create/delete ref lock (permission denied?)";
+    result.evidence = error instanceof Error ? error.message : String(error);
+  }
+
+  return result;
+}
+
+export function classifyDiagnostics(
+  repo: RepoIdentity | null,
+  ghCli: DiagnosticResult,
+  localGit: DiagnosticResult,
+  localGitWrite: DiagnosticResult,
+  connector: DiagnosticResult
+): DiagnosticsReport["recommendedFlow"] {
+  const isGitHub = repo?.provider === "github";
+  if (!isGitHub) return "Cannot publish yet";
+
+  const ghCliOk = ghCli.status === "PASS";
+  const gitRemoteOk = localGit.status === "PASS";
+  const gitWriteOk = localGitWrite.status === "PASS";
+  const connectorOk = connector.status === "PASS" || (connector.status === "PARTIAL" && !connector.blocker?.includes("auth"));
+
+  if (ghCliOk && gitRemoteOk && gitWriteOk) {
+    return "Local Git + GH CLI";
+  }
+
+  if (connectorOk) {
+    if (gitWriteOk && gitRemoteOk) {
+      return "Local Git + connector PR creation";
+    }
+    return "Connector-only";
+  }
+
+  return "Cannot publish yet";
+}
+
+export function printDiagnosticsTable(report: DiagnosticsReport) {
+  const rows = [
+    report.paths.ghCli,
+    report.paths.localGit,
+    report.paths.localGitWrite,
+    report.paths.connector,
+  ];
+
+  console.log("\nPath                | Status  | Evidence                      | Blocker");
+  console.log("--------------------|---------|-------------------------------|---------------------------");
+  for (const row of rows) {
+    const p = row.path.padEnd(20);
+    const s = row.status.padEnd(8);
+    const e = (row.evidence || "").substring(0, 30).padEnd(30);
+    const b = row.blocker || "";
+    console.log(`${p}| ${s}| ${e}| ${b}`);
+  }
+
+  console.log(`\nResolved repo: ${report.repo ? `${report.repo.owner}/${report.repo.repo}` : "Unknown"}`);
+  console.log(`Default branch: ${report.defaultBranch || "Unknown"}`);
+  console.log(`Authenticated GH CLI user: ${report.ghCliUser || "Unknown"}`);
+  console.log(`Authenticated connector user: ${report.connectorUser || "Unknown"}`);
+  console.log(`Recommended PR flow: ${report.recommendedFlow}`);
+}

package/src/core/hollowResponseFormat.test.ts

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { formatHollowResponse } from "./hollowResponseFormat.js";
+import type { HollowResponseResult } from "./codexPrompt.js";
+
+function makeResult(kind: HollowResponseResult["kind"], reason = ""): HollowResponseResult {
+  return { isHollow: true, kind, reason };
+}
+
+test("greeting produces exactly 2 lines", () => {
+  const out = formatHollowResponse(makeResult("greeting"));
+  const lines = out.split("\n");
+  assert.equal(lines.length, 2);
+  assert.match(lines[0]!, /generic greeting/);
+  assert.match(lines[1]!, /Retry/);
+});
+
+test("filler produces exactly 2 lines", () => {
+  const out = formatHollowResponse(makeResult("filler"));
+  const lines = out.split("\n");
+  assert.equal(lines.length, 2);
+  assert.match(lines[0]!, /acknowledged without acting/);
+});
+
+test("clarification produces exactly 2 lines", () => {
+  const out = formatHollowResponse(makeResult("clarification"));
+  const lines = out.split("\n");
+  assert.equal(lines.length, 2);
+  assert.match(lines[0]!, /clarification/);
+  assert.match(lines[1]!, /suggest mode/);
+});
+
+test("short-no-action produces exactly 2 lines", () => {
+  const out = formatHollowResponse(makeResult("short-no-action"));
+  const lines = out.split("\n");
+  assert.equal(lines.length, 2);
+  assert.match(lines[0]!, /too brief/);
+});
+
+test("no emoji or warning symbols in any output", () => {
+  for (const kind of ["greeting", "filler", "clarification", "short-no-action"] as const) {
+    const out = formatHollowResponse(makeResult(kind));
+    assert.doesNotMatch(out, /⚠/);
+    assert.doesNotMatch(out, /---/);
+  }
+});
+
+test("verbose=false omits raw response", () => {
+  const out = formatHollowResponse(makeResult("greeting"), "Hello.");
+  assert.doesNotMatch(out, /Hello\./);
+});
+
+test("verbose=true appends raw response", () => {
+  const out = formatHollowResponse(makeResult("greeting"), "Hello.", true);
+  assert.match(out, /Backend response: Hello\./);
+  const lines = out.split("\n");
+  assert.equal(lines.length, 4); // 2 message lines + blank + backend response
+});

package/src/core/hollowResponseFormat.ts

@@ -0,0 +1,39 @@
+import type { HollowResponseResult } from "./codexPrompt.js";
+
+const MESSAGES: Record<string, [string, string]> = {
+  greeting: [
+    "Task not executed — backend returned a generic greeting.",
+    "Retry with a more specific instruction.",
+  ],
+  filler: [
+    "Task not executed — backend acknowledged without acting.",
+    "Retry with a more specific instruction.",
+  ],
+  clarification: [
+    "Task not executed — backend asked for clarification instead of acting.",
+    "Rephrase with more detail, or switch to suggest mode.",
+  ],
+  "short-no-action": [
+    "No action confirmed — response too brief for a write-intent prompt.",
+    "Verify workspace files manually, or retry.",
+  ],
+};
+
+export function formatHollowResponse(
+  result: HollowResponseResult,
+  rawResponse?: string,
+  verbose?: boolean,
+): string {
+  const lines = MESSAGES[result.kind] ?? [
+    "Task not executed — unexpected backend response.",
+    "Retry with a more specific instruction.",
+  ];
+
+  let output = lines.join("\n");
+
+  if (verbose && rawResponse) {
+    output += `\n\nBackend response: ${rawResponse}`;
+  }
+
+  return output;
+}