gaunt-sloth-assistant 0.1.4 → 0.2.2

package/src/modules/types.ts

@@ -0,0 +1,23 @@
+import type { BaseMessage } from '@langchain/core/messages';
+
+export type Message = BaseMessage;
+
+export interface State {
+  messages: Message[];
+}
+
+export interface ProgressCallback {
+  (): void;
+}
+
+export interface ReviewOptions {
+  source: string;
+  preamble: string;
+  diff: string;
+}
+
+export interface QuestionOptions {
+  source: string;
+  preamble: string;
+  content: string;
+}

package/src/prompt.ts

@@ -0,0 +1,39 @@
+import { resolve } from 'node:path';
+import { GSLOTH_BACKSTORY } from '#src/config.js';
+import { readFileSyncWithMessages, spawnCommand } from '#src/utils.js';
+import { displayError } from '#src/consoleUtils.js';
+import { exit, getCurrentDir, getInstallDir } from '#src/systemUtils.js';
+
+export function readInternalPreamble(): string {
+  const installDir = getInstallDir();
+  const filePath = resolve(installDir, GSLOTH_BACKSTORY);
+  return readFileSyncWithMessages(filePath, 'Error reading internal preamble file at:') || '';
+}
+
+export function readPreamble(preambleFilename: string): string {
+  const currentDir = getCurrentDir();
+  const filePath = resolve(currentDir, preambleFilename);
+  return (
+    readFileSyncWithMessages(
+      filePath,
+      'Error reading preamble file at:',
+      'Consider running `gsloth init` to set up your project. Check `gsloth init --help` to see options.'
+    ) || ''
+  );
+}
+
+/**
+ * This function expects https://cli.github.com/ to be installed and authenticated.
+ * It does something like `gh pr diff 42`
+ */
+export async function getPrDiff(pr: string): Promise<string> {
+  // TODO makes sense to check if gh is available and authenticated
+  try {
+    return await spawnCommand('gh', ['pr', 'diff', pr], 'Loading PR diff...', 'Loaded PR diff.');
+  } catch (e) {
+    displayError(e instanceof Error ? e.toString() : String(e));
+    displayError(`Failed to call "gh pr diff ${pr}", see message above for details.`);
+    exit();
+    return ''; // This line will never be reached due to exit()
+  }
+}

package/src/providers/file.ts

@@ -0,0 +1,24 @@
+import { resolve } from 'node:path';
+import { display } from '#src/consoleUtils.js';
+import { readFileSyncWithMessages } from '#src/utils.js';
+import { getCurrentDir } from '#src/systemUtils.js';
+import type { ProviderConfig } from './types.js';
+
+/**
+ * Reads the text file from current dir
+ * @param _ config (unused in this provider)
+ * @param fileName
+ * @returns file contents
+ */
+export async function get(
+  _: ProviderConfig | null,
+  fileName: string | undefined
+): Promise<string | null> {
+  if (!fileName) {
+    return null;
+  }
+  const currentDir = getCurrentDir();
+  const filePath = resolve(currentDir, fileName);
+  display(`Reading file ${fileName}...`);
+  return readFileSyncWithMessages(filePath);
+}

package/src/providers/ghPrDiffProvider.ts

@@ -0,0 +1,20 @@
+import { displayWarning } from '#src/consoleUtils.js';
+import { execAsync } from '#src/utils.js';
+import type { ProviderConfig } from './types.js';
+
+/**
+ * Gets PR diff using gh command line tool
+ * @param _ config (unused in this provider)
+ * @param pr PR number
+ * @returns PR diff
+ */
+export async function get(
+  _: ProviderConfig | null,
+  pr: string | undefined
+): Promise<string | null> {
+  if (!pr) {
+    displayWarning('No PR provided');
+    return null;
+  }
+  return execAsync(`gh pr diff ${pr}`);
+}

package/src/providers/jiraIssueLegacyProvider.ts

@@ -0,0 +1,103 @@
+import { display, displayError, displayWarning } from '#src/consoleUtils.js';
+import { env } from '#src/systemUtils.js';
+import type { JiraLegacyConfig } from '#src/providers/types.js';
+
+interface JiraIssueResponse {
+  fields: {
+    summary: string;
+    description: string;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+
+/**
+ * Gets Jira issue using Atlassian REST API v2 with unscoped API token (aka Legacy Token)
+ * @param config Jira configuration
+ * @param issueId Jira issue ID
+ * @returns Jira issue content
+ */
+export async function get(
+  config: Partial<JiraLegacyConfig>,
+  issueId: string | undefined
+): Promise<string | null> {
+  if (!config) {
+    displayWarning('No Jira config provided');
+    return null;
+  }
+  if (!issueId) {
+    displayWarning('No issue ID provided');
+    return null;
+  }
+  if (!config.baseUrl) {
+    displayWarning('No Jira base URL provided');
+    return null;
+  }
+
+  // Get username from environment variable or config
+  const username = env.JIRA_USERNAME || config.username;
+  if (!username) {
+    throw new Error(
+      'Missing JIRA username. The username can be defined as JIRA_USERNAME environment variable or as "username" in config.'
+    );
+  }
+
+  // Get token from environment variable or config
+  const token = env.JIRA_LEGACY_API_TOKEN || config.token;
+  if (!token) {
+    throw new Error(
+      'Missing JIRA Legacy API token. The legacy token can be defined as JIRA_LEGACY_API_TOKEN environment variable or as "token" in config.'
+    );
+  }
+
+  try {
+    const issue = await getJiraIssue(
+      {
+        ...(config as JiraLegacyConfig),
+        username,
+        token,
+      },
+      issueId
+    );
+    if (!issue) {
+      return null;
+    }
+
+    const summary = issue.fields.summary;
+    const description = issue.fields.description;
+
+    return `Jira Issue: ${issueId}\nSummary: ${summary}\n\nDescription:\n${description}`;
+  } catch (error) {
+    displayError(
+      `Failed to get Jira issue: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+
+/**
+ * Helper function to get Jira issue details
+ * @param config Jira configuration
+ * @param issueId Jira issue ID
+ * @returns Jira issue response
+ */
+async function getJiraIssue(config: JiraLegacyConfig, issueId: string): Promise<JiraIssueResponse> {
+  const auth = Buffer.from(`${config.username}:${config.token}`).toString('base64');
+  const url = `${config.baseUrl}${issueId}`;
+  if (config.displayUrl) {
+    display(`Loading Jira issue ${config.displayUrl}${issueId}`);
+  }
+  display(`Retrieving jira from api ${url.replace(/^https?:\/\//, '')}`);
+  const response = await fetch(url, {
+    headers: {
+      Authorization: `Basic ${auth}`,
+      Accept: 'application/json',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch Jira issue from ${url} with status: ${response.statusText}`);
+  }
+
+  return response.json();
+}

package/src/providers/jiraIssueProvider.ts

@@ -0,0 +1,133 @@
+import { display, displayError, displayWarning } from '#src/consoleUtils.js';
+import { env } from '#src/systemUtils.js';
+import type { JiraConfig } from './types.js';
+
+interface JiraIssueResponse {
+  fields: {
+    summary: string;
+    description: string;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+
+/**
+ * Gets Jira issue using Atlassian REST API v3 with Personal Access Token
+ *
+ * TODO we need to figure out how would this work with public jira.
+ *
+ * @param config Jira configuration
+ * @param issueId Jira issue ID
+ * @returns Jira issue content
+ */
+export async function get(
+  config: Partial<JiraConfig> | null,
+  issueId: string | undefined
+): Promise<string | null> {
+  if (!config) {
+    displayWarning('No Jira config provided');
+    return null;
+  }
+  if (!issueId) {
+    displayWarning('No issue ID provided');
+    return null;
+  }
+
+  // Get username from environment variable or config
+  const username = env.JIRA_USERNAME || config.username;
+  if (!username) {
+    throw new Error(
+      'Missing JIRA username. The username can be defined as JIRA_USERNAME environment variable or as "username" in config.'
+    );
+  }
+
+  // Get token from environment variable or config
+  const token = env.JIRA_API_PAT_TOKEN || config.token;
+  if (!token) {
+    throw new Error(
+      'Missing JIRA PAT token. The token can be defined as JIRA_API_PAT_TOKEN environment variable or as "token" in config.'
+    );
+  }
+
+  // Get cloud ID from environment variable or config
+  const cloudId = env.JIRA_CLOUD_ID || config.cloudId;
+  if (!cloudId) {
+    throw new Error(
+      'Missing JIRA Cloud ID. The Cloud ID can be defined as JIRA_CLOUD_ID environment variable or as "cloudId" in config.'
+    );
+  }
+
+  try {
+    const issue = await getJiraIssue(
+      {
+        ...config,
+        username,
+        token,
+        cloudId,
+      },
+      issueId
+    );
+    if (!issue) {
+      return null;
+    }
+
+    const summary = issue.fields.summary;
+    const description = issue.fields.description;
+
+    return `Jira Issue: ${issueId}\nSummary: ${summary}\n\nDescription:\n${description}`;
+  } catch (error) {
+    displayError(
+      `Failed to get Jira issue: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+
+/**
+ * Helper function to get Jira issue details using Atlassian REST API v3
+ * @param config Jira configuration
+ * @param jiraKey Jira issue ID
+ * @returns Jira issue response
+ */
+async function getJiraIssue(config: JiraConfig, jiraKey: string): Promise<JiraIssueResponse> {
+  // Jira Cloud ID can be found by authenticated user at https://company.atlassian.net/_edge/tenant_info
+
+  // According to doc https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issues/#api-rest-api-3-issue-issueidorkey-get permissions to read this resource:
+  // either Classic (RECOMMENDED) read:jira-work
+  // or Granular read:issue-meta:jira, read:issue-security-level:jira, read:issue.vote:jira, read:issue.changelog:jira, read:avatar:jira, read:issue:jira, read:status:jira, read:user:jira, read:field-configuration:jira
+  const apiUrl = `https://api.atlassian.com/ex/jira/${config.cloudId}/rest/api/3/issue/${jiraKey}`;
+  if (config.displayUrl) {
+    display(`Loading Jira issue ${config.displayUrl}${jiraKey}`);
+  }
+  display(`Retrieving jira from api ${apiUrl.replace(/^https?:\/\//, '')}`);
+
+  // Encode credentials for Basic Authentication header
+  const credentials = `${config.username}:${config.token}`;
+  const encodedCredentials = Buffer.from(credentials).toString('base64');
+  const authHeader = `Basic ${encodedCredentials}`;
+
+  // Define request headers
+  const headers = {
+    Authorization: authHeader,
+    Accept: 'application/json; charset=utf-8',
+    'Accept-Language': 'en-US,en;q=0.9', // Prevents errors in other languages
+  };
+
+  const response = await fetch(apiUrl, {
+    method: 'GET',
+    headers: headers,
+  });
+
+  if (!response?.ok) {
+    try {
+      const errorData = await response.json();
+      throw new Error(
+        `Failed to fetch Jira issue: ${response.statusText} - ${JSON.stringify(errorData)}`
+      );
+    } catch (_e) {
+      throw new Error(`Failed to fetch Jira issue: ${response?.statusText}`);
+    }
+  }
+
+  return response.json();
+}

package/src/providers/text.ts

@@ -0,0 +1,14 @@
+import type { ProviderConfig } from './types.js';
+
+/**
+ * Returns the provided text as is
+ * @param _ config (unused in this provider)
+ * @param text Text to return
+ * @returns The provided text
+ */
+export async function get(
+  _: ProviderConfig | null,
+  text: string | undefined
+): Promise<string | null> {
+  return text ?? null;
+}

package/src/providers/types.ts

@@ -0,0 +1,24 @@
+export interface ProviderConfig {
+  username?: string;
+  token?: string;
+  baseUrl?: string;
+  [key: string]: unknown;
+}
+
+export interface JiraLegacyConfig extends ProviderConfig {
+  username: string;
+  baseUrl: string;
+  displayUrl?: string;
+  token: string;
+}
+
+export interface JiraConfig extends ProviderConfig {
+  cloudId: string;
+  username: string;
+  displayUrl?: string;
+  token: string;
+}
+
+export interface Provider {
+  get: (config: ProviderConfig | null, id: string | undefined) => Promise<string | null>;
+}

package/src/systemUtils.ts

@@ -0,0 +1,52 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'url';
+
+/**
+ * This file contains all system functions and objects that are globally available
+ * but not imported directly, such as process.stdin, process.stdout, process.argv,
+ * process.env, process.cwd(), process.exit(), etc.
+ *
+ * By centralizing these in one file, we improve testability and make it easier
+ * to mock these dependencies in tests.
+ */
+
+interface InnerState {
+  installDir: string | null | undefined;
+}
+
+const innerState: InnerState = {
+  installDir: undefined,
+};
+
+// Process-related functions and objects
+export const getCurrentDir = (): string => process.cwd();
+export const getInstallDir = (): string => {
+  if (innerState.installDir) {
+    return innerState.installDir;
+  }
+  throw new Error('Install directory not set');
+};
+export const exit = (code?: number): never => process.exit(code || 0);
+export const stdin = process.stdin;
+export const stdout = process.stdout;
+export const argv = process.argv;
+export const env = process.env;
+
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Provide the path to the entry point of the application.
+ * This is used to set the install directory.
+ * This is called from index.js root entry point.
+ */
+export const setEntryPoint = (indexJs: string): void => {
+  const filePath = fileURLToPath(indexJs);
+  const dirPath = dirname(filePath);
+  innerState.installDir = resolve(dirPath);
+};
+
+// Console-related functions
+export const log = (message: string): void => console.log(message);
+export const error = (message: string): void => console.error(message);
+export const warn = (message: string): void => console.warn(message);
+export const info = (message: string): void => console.info(message);
+export const debug = (message: string): void => console.debug(message);

package/src/utils.ts

@@ -0,0 +1,225 @@
+import { display, displayError, displaySuccess, displayWarning } from '#src/consoleUtils.js';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { SlothConfig, slothContext } from '#src/config.js';
+import { resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+import { exit, stdin, stdout, argv, getCurrentDir, getInstallDir } from '#src/systemUtils.js';
+import url from 'node:url';
+import { Command } from 'commander';
+
+export function toFileSafeString(string: string): string {
+  return string.replace(/[^A-Za-z0-9]/g, '-');
+}
+
+export function fileSafeLocalDate(): string {
+  const date = new Date();
+  const offsetMs = date.getTimezoneOffset() * 60 * 1000;
+  const msLocal = date.getTime() - offsetMs;
+  const dateLocal = new Date(msLocal);
+  const iso = dateLocal.toISOString();
+  const isoLocal = iso.slice(0, 19);
+  return toFileSafeString(isoLocal);
+}
+
+export function readFileFromCurrentDir(fileName: string): string {
+  const currentDir = getCurrentDir();
+  const filePath = resolve(currentDir, fileName);
+  display(`Reading file ${fileName}...`);
+  return readFileSyncWithMessages(filePath);
+}
+
+export function writeFileIfNotExistsWithMessages(filePath: string, content: string): void {
+  display(`checking ${filePath} existence`);
+  if (!existsSync(filePath)) {
+    writeFileSync(filePath, content);
+    displaySuccess(`Created ${filePath}`);
+  } else {
+    displayWarning(`${filePath} already exists`);
+  }
+}
+
+export function readFileSyncWithMessages(
+  filePath: string,
+  errorMessageIn?: string,
+  noFileMessage?: string
+): string {
+  const errorMessage = errorMessageIn ?? 'Error reading file at: ';
+  try {
+    return readFileSync(filePath, { encoding: 'utf8' });
+  } catch (error) {
+    displayError(errorMessage + filePath);
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      displayWarning(noFileMessage ?? 'Please ensure the file exists.');
+    } else {
+      displayError((error as Error).message);
+    }
+    exit(1); // Exit gracefully after error
+    throw error; // This line will never be reached due to exit(1), but satisfies TypeScript
+  }
+}
+
+export function readStdin(program: Command): Promise<void> {
+  return new Promise((resolvePromise) => {
+    if (stdin.isTTY) {
+      program.parseAsync().then(() => resolvePromise());
+    } else {
+      // Support piping diff into gsloth
+      const progressIndicator = new ProgressIndicator('reading STDIN');
+      progressIndicator.indicate();
+
+      stdin.on('readable', function (this: NodeJS.ReadStream) {
+        const chunk = this.read();
+        progressIndicator.indicate();
+        if (chunk !== null) {
+          const chunkStr = chunk.toString('utf8');
+          (slothContext as { stdin: string }).stdin = slothContext.stdin + chunkStr;
+        }
+      });
+
+      stdin.on('end', function () {
+        program.parseAsync(argv).then(() => resolvePromise());
+      });
+    }
+  });
+}
+
+interface SpawnOutput {
+  stdout: string;
+  stderr: string;
+}
+
+export async function spawnCommand(
+  command: string,
+  args: string[],
+  progressMessage: string,
+  successMessage: string
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const progressIndicator = new ProgressIndicator(progressMessage);
+    const out: SpawnOutput = { stdout: '', stderr: '' };
+    const spawned = spawn(command, args);
+
+    spawned.stdout.on('data', async (stdoutChunk) => {
+      progressIndicator.indicate();
+      out.stdout += stdoutChunk.toString();
+    });
+
+    spawned.stderr.on('data', (err) => {
+      progressIndicator.indicate();
+      out.stderr += err.toString();
+    });
+
+    spawned.on('error', (err) => {
+      reject(err.toString());
+    });
+
+    spawned.on('close', (code) => {
+      if (code === 0) {
+        display(successMessage);
+        resolve(out.stdout);
+      } else {
+        displayError(`Failed to spawn command with code ${code}`);
+        reject(out.stdout + ' ' + out.stderr);
+      }
+    });
+  });
+}
+
+export function getSlothVersion(): string {
+  // TODO figure out if this can be injected with TS
+  const installDir = getInstallDir();
+  const jsonPath = resolve(installDir, 'package.json');
+  const projectJson = readFileSync(jsonPath, { encoding: 'utf8' });
+  return JSON.parse(projectJson).version;
+}
+
+export class ProgressIndicator {
+  private hasBeenCalled: boolean;
+  private initialMessage: string;
+
+  constructor(initialMessage: string) {
+    this.hasBeenCalled = false;
+    this.initialMessage = initialMessage;
+  }
+
+  indicate(): void {
+    if (this.hasBeenCalled) {
+      stdout.write('.');
+    } else {
+      this.hasBeenCalled = true;
+      stdout.write(this.initialMessage);
+    }
+  }
+}
+
+interface LLMOutput {
+  messages: Array<{
+    content: string;
+  }>;
+}
+
+/**
+ * Extracts the content of the last message from an LLM response
+ * @param output - The output from the LLM containing messages
+ * @returns The content of the last message
+ */
+export function extractLastMessageContent(output: LLMOutput): string {
+  if (!output || !output.messages || !output.messages.length) {
+    return '';
+  }
+  return output.messages[output.messages.length - 1].content;
+}
+
+/**
+ * Dynamically imports a module from a file path from the outside of the installation dir
+ * @param filePath - The path to the file to import
+ * @returns A promise that resolves to the imported module
+ */
+export function importExternalFile(
+  filePath: string
+): Promise<{ configure: (module: string) => Promise<Partial<SlothConfig>> }> {
+  const configFileUrl = url.pathToFileURL(filePath).toString();
+  return import(configFileUrl);
+}
+
+/**
+ * Alias for importExternalFile for backward compatibility with tests
+ * @param filePath - The path to the file to import
+ * @returns A promise that resolves to the imported module
+ */
+export const importFromFilePath = importExternalFile;
+
+/**
+ * Reads multiple files from the current directory and returns their contents
+ * @param fileNames - Array of file names to read
+ * @returns Combined content of all files with proper formatting
+ */
+export function readMultipleFilesFromCurrentDir(fileNames: string | string[]): string {
+  if (!Array.isArray(fileNames)) {
+    return readFileFromCurrentDir(fileNames);
+  }
+
+  return fileNames
+    .map((fileName) => {
+      const content = readFileFromCurrentDir(fileName);
+      return `${fileName}:\n\`\`\`\n${content}\n\`\`\``;
+    })
+    .join('\n\n');
+}
+
+export async function execAsync(command: string): Promise<string> {
+  const { exec } = await import('node:child_process');
+  return new Promise((resolve, reject) => {
+    exec(command, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      if (stderr) {
+        reject(new Error(stderr));
+        return;
+      }
+      resolve(stdout.trim());
+    });
+  });
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "sourceMap": true,
+    "typeRoots": ["./node_modules/@types", "./src/types"],
+    "allowJs": true,
+    "checkJs": false,
+    "baseUrl": ".",
+    "paths": {
+      "#src/*": ["./src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "spec"]
+}