embed-markdown/index.js

const { execSync } = require("child_process");
const fs = require("fs");

const core = require("@actions/core");
const github = require("@actions/github");

function listMarkdownFiles(executor = execSync) {
  const output = executor("git ls-files '*.md'", {
    encoding: "utf8",
  }).trim();

  return output ? output.split("\n").filter(Boolean) : [];
}

function getConfig({
  coreModule = core,
  githubModule = github,
  env = process.env,
} = {}) {
  const apiUrl =
    coreModule.getInput("api_url") || "http://agent-api.k8s.private";
  const apiToken = coreModule.getInput("api_token");
  const route = coreModule.getInput("route") || "agent-lake";
  const method = coreModule.getInput("method") || "embeddings_insert";
  const debug =
    (coreModule.getInput("debug") || "false").toLowerCase() === "true";

  const repoFull = env.GITHUB_REPOSITORY || "";
  const [owner = "", repo = ""] = repoFull.split("/");
  const segmentId = "docs.code";

  const serverUrl = (
    env.GITHUB_SERVER_URL ||
    githubModule.context.serverUrl ||
    "https://git.yusufali.ca"
  ).replace(/\/$/, "");

  const headers = {
    "Content-Type": "application/json",
  };

  if (apiToken) {
    headers.Apitoken = apiToken;
  }

  return {
    apiUrl,
    apiToken,
    route,
    method,
    debug,
    owner,
    repo,
    segmentId,
    serverUrl,
    headers,
  };
}

function sanitizeDocumentId(value) {
  return value.replace(/[^A-Za-z0-9.]/g, "");
}

function buildStoreText({ owner, repo, file, content }) {
  return [
    `repo_name: ${repo}`,
    `repo_owner: ${owner}`,
    `path: ${file}`,
    "",
    content,
  ].join("\n");
}

function buildRequestPayload({
  route,
  method,
  segmentId,
  owner,
  repo,
  file,
  content,
}) {
  return {
    type: "input",
    route,
    argumentId: "plain",
    force: true,
    instanceId: null,
    inputs: {
      method,
      inputs: {
        segment_id: segmentId,
        document_id: sanitizeDocumentId([owner, repo, file].join(".")),
        embed_text: "",
        store_text: buildStoreText({ owner, repo, file, content }),
      },
    },
  };
}

async function post(
  { apiUrl, headers, requestPayload, coreModule, fetchFn, waitFn },
  retries = 0,
) {
  try {
    const response = await fetchFn(apiUrl, {
      method: "POST",
      headers,
      body: JSON.stringify(requestPayload),
    });

    const responseText = await response.text();
    if (!response.ok) {
      coreModule.setFailed(
        `Agent API request failed (${response.status}): ${responseText}`,
      );
    } else {
      coreModule.info(`Agent response: ${responseText}`);
    }
  } catch (error) {
    if (retries < 5) {
      const delayMs = 1000 * (retries + 1);
      await waitFn(delayMs);
      return post(
        { apiUrl, headers, requestPayload, coreModule, fetchFn, waitFn },
        retries + 1,
      );
    }
    coreModule.setFailed(`Error sending task to agent: ${error}`);
  }
}

async function main({
  coreModule = core,
  githubModule = github,
  env = process.env,
  executor = execSync,
  fsModule = fs,
  fetchFn = fetch,
  waitFn = (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)),
} = {}) {
  const config = getConfig({ coreModule, githubModule, env });
  const markdownFiles = listMarkdownFiles(executor);

  for (const file of markdownFiles) {
    const content = fsModule.readFileSync(file, "utf8");
    const requestPayload = buildRequestPayload({
      route: config.route,
      method: config.method,
      segmentId: config.segmentId,
      owner: config.owner,
      repo: config.repo,
      file,
      content,
    });

    if (config.debug) {
      coreModule.info(`API URL: ${config.apiUrl}`);
      coreModule.info(`Route: ${config.route}`);
      coreModule.info(`Server URL: ${config.serverUrl}`);
      coreModule.info(`Using auth: ${Boolean(config.apiToken)}`);
      coreModule.info(`Request payload: ${JSON.stringify(requestPayload)}`);
    }

    await post({
      apiUrl: config.apiUrl,
      headers: config.headers,
      requestPayload,
      coreModule,
      fetchFn,
      waitFn,
    });
  }
}

module.exports = {
  buildRequestPayload,
  buildStoreText,
  getConfig,
  listMarkdownFiles,
  main,
  post,
  sanitizeDocumentId,
};

if (require.main === module) {
  main();
}