gaunt-sloth-assistant 0.1.5 → 0.3.0

package/src/utils.ts

@@ -0,0 +1,232 @@
+import { display, displayError, displaySuccess, displayWarning } from '#src/consoleUtils.js';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { SlothConfig } from '#src/config.js';
+import { resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+import { getCurrentDir, getInstallDir, stdout } from '#src/systemUtils.js';
+import url from 'node:url';
+
+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 ${filePath}...`);
+  return readFileSyncWithMessages(filePath);
+}
+
+export function readFileFromCurrentOrInstallDir(filePath: string, silentCurrent?: boolean): string {
+  const currentDir = getCurrentDir();
+  const currentFilePath = resolve(currentDir, filePath);
+  if (!silentCurrent) {
+    display(`Reading file ${currentFilePath}...`);
+  }
+
+  try {
+    return readFileSync(currentFilePath, { encoding: 'utf8' });
+  } catch (_error) {
+    if (!silentCurrent) {
+      display(`The ${currentFilePath} not found or can\'t be read, trying install directory...`);
+    }
+    const installDir = getInstallDir();
+    const installFilePath = resolve(installDir, filePath);
+    try {
+      return readFileSync(installFilePath, { encoding: 'utf8' });
+    } catch (readFromInstallDirError) {
+      displayError(`The ${installFilePath} not found or can\'t be read.`);
+      throw readFromInstallDirError;
+    }
+  }
+}
+
+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);
+    }
+    throw error;
+  }
+}
+
+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, true);
+    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 interval: number | undefined = undefined;
+
+  constructor(initialMessage: string, manual?: boolean) {
+    stdout.write(initialMessage);
+    if (!manual) {
+      this.interval = setInterval(this.indicateInner, 1000) as unknown as number;
+    }
+  }
+
+  private indicateInner(): void {
+    stdout.write('.');
+  }
+
+  indicate(): void {
+    if (this.interval) {
+      throw new Error('ProgressIndicator.indicate only to be called in manual mode');
+    }
+    this.indicateInner();
+  }
+
+  stop(): void {
+    if (this.interval) {
+      clearInterval(this.interval);
+    }
+    stdout.write('\n');
+  }
+}
+
+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"]
+}

package/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['spec/**/*.spec.ts'],
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+    },
+    globals: true,
+  },
+});

package/.eslint.config.mjs

@@ -1,72 +0,0 @@
-// TODO
-// // eslint.config.mjs
-// // Remember to install dependencies:
-// // npm install --save-dev eslint @eslint/js eslint-plugin-n globals eslint-config-prettier
-// // yarn add --dev eslint @eslint/js eslint-plugin-n globals eslint-config-prettier
-// // pnpm add -D eslint @eslint/js eslint-plugin-n globals eslint-config-prettier
-//
-// import js from "@eslint/js"; // Provides eslint:recommended and eslint:all
-// import pluginN from "eslint-plugin-n"; // Successor to eslint-plugin-node
-// import globals from "globals"; // Provides standard global variables (node, browser, etc.)
-// import eslintConfigPrettier from "eslint-config-prettier"; // Disables rules that conflict with Prettier
-//
-// export default [
-//     // 1. Global Ignores
-//     // Files/directories to ignore globally. You can add more patterns.
-//     {
-//         ignores: [
-//             "node_modules/",
-//             "dist/", // Common build output directory
-//             "build/",  // Another common build output directory
-//             ".env",
-//             "*.log",
-//             "coverage/", // Test coverage reports
-//         ],
-//     },
-//
-//     // 2. ESLint Recommended Rules
-//     // Provides a good baseline set of rules maintained by the ESLint team.
-//     js.configs.recommended,
-//
-//     // 3. Node.js Specific Rules (using eslint-plugin-n)
-//     // Recommended configuration for Node.js projects.
-//     pluginN.configs['flat/recommended'],
-//
-//     // 4. Custom Configuration for your JS/MJS files
-//     {
-//         files: ["**/*.{js,mjs}"], // Apply these settings to .js and .mjs files
-//         languageOptions: {
-//             ecmaVersion: "latest", // Use the latest ECMAScript features
-//             sourceType: "module",  // Set to "module" for ES Modules (import/export)
-//             globals: {
-//                 ...globals.nodeBuiltin, // Includes Node.js built-in globals like 'process', 'Buffer', etc.
-//                 // Add other global environments if needed:
-//                 // ...globals.browser, // If your code also runs in the browser
-//                 // Add any other custom global variables your project uses:
-//                 // myCustomGlobal: "readonly",
-//             }
-//         },
-//         rules: {
-//             // Customize or override rules here
-//             "no-unused-vars": ["warn", { "argsIgnorePattern": "^_" }], // Warn about unused vars, except those starting with _
-//             "semi": ["error", "always"], // Enforce semicolons
-//             "quotes": ["warn", "single"], // Prefer single quotes
-//             "indent": ["warn", 2],        // Enforce 2-space indentation
-//
-//             // Node specific rule examples (from eslint-plugin-n) - adjust as needed
-//             "n/no-unpublished-import": ["error", {
-//                 "allowModules": [], // Add exceptions for modules used in dev but not in dependencies
-//             }],
-//             "n/no-missing-import": "error", // Ensure imports can be resolved
-//             "n/no-extraneous-import": "error", // Prevent importing devDependencies in production code
-//
-//             // Add other rules or modify existing ones based on your team's style guide
-//         }
-//     },
-//
-//     // 5. Prettier Configuration (Optional but Recommended)
-//     // IMPORTANT: This MUST be the LAST configuration object in the array.
-//     // It disables ESLint rules that would conflict with Prettier's formatting.
-//     // Assumes you are using Prettier for code formatting.
-//     eslintConfigPrettier,
-// ];

package/.github/dependabot.yml

@@ -1,11 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
-
-version: 2
-updates:
-  - package-ecosystem: "npm" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "weekly"

package/.github/workflows/ci.yml

@@ -1,33 +0,0 @@
-name: Tests and Lint
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  test-and-lint:
-    runs-on: ubuntu-latest
-    
-    strategy:
-      matrix:
-        node-version: [22.x]
-
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v4
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    
-    - name: Install dependencies
-      run: npm ci
-    
-    - name: Run ESLint
-      run: npm run lint
-    
-    - name: Run Tests
-      run: npm test

package/spec/.gsloth.config.js

@@ -1,22 +0,0 @@
-export async function configure(importFunction, global) {
-    const test = await importFunction('@langchain/core/utils/testing');
-    return {
-        llm: new test.FakeListChatModel({
-            responses: ["First LLM message", "Second LLM message"],
-        }),
-        requirementsProviderConfig: {
-            'jira-legacy': {
-                username: 'user.name@company.com', // Your Jira username/email
-                token: 'YoUrToKeN',     // Replace with your real Jira API token
-                baseUrl: 'https://company.atlassian.net/rest/api/2/issue/'  // Your Jira instance base URL
-            }
-        },
-        requirementsProvider: "jira-legacy",
-        contentProvider: "somethingSpecial",
-        contentProviderConfig: {
-            somethingSpecial: {
-                test: 'example'
-            }
-        }
-    };
-}

package/spec/.gsloth.config.json

@@ -1,25 +0,0 @@
-{
-  "llm": {
-    "type": "fake",
-    "responses": ["First LLM message", "Second LLM message"]
-  },
-  "requirementsProviderConfig": {
-    "jira-legacy": {
-      "username": "user.name@company.com",
-      "token": "YoUrToKeN",
-      "baseUrl": "https://company.atlassian.net/rest/api/2/issue/"
-    }
-  },
-  "requirementsProvider": "file",
-  "contentProvider": "somethingSpecial",
-  "contentProviderConfig": {
-    "somethingSpecial": {
-      "test": "example"
-    }
-  },
-  "commands": {
-    "pr": {
-      "requirementsProvider": "jira-legacy"
-    }
-  }
-}

package/spec/askCommand.spec.js

@@ -1,92 +0,0 @@
-import {Command} from 'commander';
-import * as td from 'testdouble';
-
-describe('askCommand', function (){
-
-    beforeEach(async function() {
-        td.reset();
-        this.askQuestion = td.function();
-        this.prompt = await td.replaceEsm("../src/prompt.js");
-        td.when(this.prompt.readInternalPreamble()).thenReturn("INTERNAL PREAMBLE");
-        this.questionAnsweringMock = await td.replaceEsm("../src/modules/questionAnsweringModule.js");
-        await td.replaceEsm("../src/config.js", {
-            SLOTH_INTERNAL_PREAMBLE: '.gsloth.preamble.internal.md',
-            USER_PROJECT_REVIEW_PREAMBLE: '.gsloth.preamble.review.md',
-            slothContext: {
-                config: {},
-                currentDir: '/mock/current/dir'
-            },
-            initConfig: td.function()
-        });
-        const readFileFromCurrentDir = td.function();
-        const readMultipleFilesFromCurrentDir = td.function();
-        const extractLastMessageContent = td.function();
-        const toFileSafeString = td.function();
-        const fileSafeLocalDate = td.function();
-        this.utilsMock = {
-            readFileFromCurrentDir,
-            readMultipleFilesFromCurrentDir,
-            ProgressIndicator: td.constructor(),
-            extractLastMessageContent,
-            toFileSafeString,
-            fileSafeLocalDate
-        };
-        await td.replaceEsm("../src/utils.js", this.utilsMock);
-        td.when(this.utilsMock.readFileFromCurrentDir("test.file")).thenReturn("FILE CONTENT");
-        td.when(this.utilsMock.readMultipleFilesFromCurrentDir(["test.file"])).thenReturn("test.file:\n```\nFILE CONTENT\n```");
-        td.when(this.questionAnsweringMock.askQuestion(
-            'sloth-ASK',
-            td.matchers.anything(),
-            td.matchers.anything())
-        ).thenDo(this.askQuestion);
-    });
-
-    it('Should call askQuestion with message', async function() {
-        const { askCommand } = await import("../src/commands/askCommand.js");
-        const program = new Command();
-        await askCommand(program, {});
-        await program.parseAsync(['na', 'na', 'ask', 'test message']);
-        td.verify(this.askQuestion('sloth-ASK', "INTERNAL PREAMBLE", "test message"));
-    });
-
-    it('Should call askQuestion with message and file content', async function() {
-        const { askCommand } = await import("../src/commands/askCommand.js");
-        const program = new Command();
-        await askCommand(program, {});
-        await program.parseAsync(['na', 'na', 'ask', 'test message', '-f', 'test.file']);
-        td.verify(this.askQuestion('sloth-ASK', "INTERNAL PREAMBLE", "test message\ntest.file:\n```\nFILE CONTENT\n```"));
-    });
-
-    it('Should call askQuestion with message and multiple file contents', async function() {
-        const { askCommand } = await import("../src/commands/askCommand.js");
-        const program = new Command();
-        await askCommand(program, {});
-        td.when(this.utilsMock.readMultipleFilesFromCurrentDir(["test.file", "test2.file"]))
-            .thenReturn("test.file:\n```\nFILE CONTENT\n```\n\ntest2.file:\n```\nFILE2 CONTENT\n```");
-        await program.parseAsync(['na', 'na', 'ask', 'test message', '-f', 'test.file', 'test2.file']);
-        td.verify(this.askQuestion('sloth-ASK', "INTERNAL PREAMBLE", "test message\ntest.file:\n```\nFILE CONTENT\n```\n\ntest2.file:\n```\nFILE2 CONTENT\n```"));
-    });
-
-    it('Should display help correctly', async function() {
-        const { askCommand } = await import("../src/commands/askCommand.js");
-        const program = new Command();
-        const testOutput = { text: '' };
-
-        program.configureOutput({
-            writeOut: (str) => testOutput.text += str,
-            writeErr: (str) => testOutput.text += str
-        });
-
-        await askCommand(program, {});
-
-        const commandUnderTest = program.commands.find(c => c.name() == 'ask');
-
-        expect(commandUnderTest).toBeDefined();
-        commandUnderTest.outputHelp();
-
-        // Verify help content
-        expect(testOutput.text).toContain('Ask a question');
-        expect(testOutput.text).toContain('<message>');
-        expect(testOutput.text).toContain('-f, --file');
-    });
-});