gaunt-sloth-assistant 0.2.2 → 0.3.1

package/src/modules/reviewModule.ts

@@ -1,27 +1,17 @@
-import type { SlothContext } from '#src/config.js';
 import { slothContext } from '#src/config.js';
 import { display, displayDebug, displayError, displaySuccess } from '#src/consoleUtils.js';
-import type { Message, ProgressCallback, State } from '#src/modules/types.js';
-import { getCurrentDir, stdout } from '#src/systemUtils.js';
-import { fileSafeLocalDate, ProgressIndicator, toFileSafeString } from '#src/utils.js';
-import { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import { AIMessageChunk, HumanMessage, SystemMessage } from '@langchain/core/messages';
-import { END, MemorySaver, MessagesAnnotation, START, StateGraph } from '@langchain/langgraph';
+import { stdout } from '#src/systemUtils.js';
+import { generateStandardFileName, ProgressIndicator } from '#src/utils.js';
 import { writeFileSync } from 'node:fs';
-import path from 'node:path';
+import { invoke } from '#src/llmUtils.js';
+import { getGslothFilePath } from '#src/filePathUtils.js';
 
 export async function review(source: string, preamble: string, diff: string): Promise<void> {
   const progressIndicator = new ProgressIndicator('Reviewing.');
-  const outputContent = await reviewInner(
-    slothContext,
-    () => progressIndicator.indicate(),
-    preamble,
-    diff
-  );
-  const filePath = path.resolve(
-    getCurrentDir(),
-    toFileSafeString(source) + '-' + fileSafeLocalDate() + '.md'
-  );
+  const outputContent = await invoke(slothContext.config.llm, slothContext.session, preamble, diff);
+  progressIndicator.stop();
+  const filename = generateStandardFileName(source);
+  const filePath = getGslothFilePath(filename);
   stdout.write('\n');
   display(`writing ${filePath}`);
   stdout.write('\n');
@@ -37,45 +27,3 @@ export async function review(source: string, preamble: string, diff: string): Pr
     // exit(1);
   }
 }
-
-export async function reviewInner(
-  context: SlothContext,
-  indicateProgress: ProgressCallback,
-  preamble: string,
-  diff: string
-): Promise<string> {
-  // This node receives the current state (messages) and invokes the LLM
-  const callModel = async (state: State): Promise<{ messages: AIMessageChunk }> => {
-    // state.messages will contain the list including the system preamble and user diff
-    const response = await (context.config.llm as BaseChatModel).invoke(state.messages);
-    // MessagesAnnotation expects the node to return the new message(s) to be added to the state.
-    // Wrap the response in an array if it's a single message object.
-    return { messages: response };
-  };
-
-  // Define the graph structure with MessagesAnnotation state
-  const workflow = new StateGraph(MessagesAnnotation)
-    // Define the node and edge
-    .addNode('model', callModel)
-    .addEdge(START, 'model') // Start at the 'model' node
-    .addEdge('model', END); // End after the 'model' node completes
-
-  // Set up memory (optional but good practice for potential future multi-turn interactions)
-  const memory = new MemorySaver(); // TODO extract to config
-
-  // Compile the workflow into a runnable app
-  const app = workflow.compile({ checkpointer: memory });
-
-  // Construct the initial the messages including the preamble as a system message
-  const messages: Message[] = [new SystemMessage(preamble), new HumanMessage(diff)];
-
-  indicateProgress();
-  // TODO create proper progress indicator for async tasks.
-  const progress = setInterval(() => indicateProgress(), 1000);
-  const output = await app.invoke({ messages }, context.session);
-  clearInterval(progress);
-  const lastMessage = output.messages[output.messages.length - 1];
-  return typeof lastMessage.content === 'string'
-    ? lastMessage.content
-    : JSON.stringify(lastMessage.content);
-}

package/src/prompt.ts

@@ -1,25 +1,43 @@
-import { resolve } from 'node:path';
-import { GSLOTH_BACKSTORY } from '#src/config.js';
-import { readFileSyncWithMessages, spawnCommand } from '#src/utils.js';
+import {
+  readFileFromCurrentDir,
+  readFileFromCurrentOrInstallDir,
+  spawnCommand,
+} from '#src/utils.js';
 import { displayError } from '#src/consoleUtils.js';
-import { exit, getCurrentDir, getInstallDir } from '#src/systemUtils.js';
+import { exit } from '#src/systemUtils.js';
+import { GSLOTH_BACKSTORY } from '#src/config.js';
+import { getGslothConfigReadPath } from '#src/filePathUtils.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 readBackstory(): string {
+  return readFileFromCurrentOrInstallDir(GSLOTH_BACKSTORY, true);
 }
 
-export function readPreamble(preambleFilename: string): string {
-  const currentDir = getCurrentDir();
-  const filePath = resolve(currentDir, preambleFilename);
-  return (
-    readFileSyncWithMessages(
-      filePath,
-      'Error reading preamble file at:',
+export function readGuidelines(guidelinesFilename: string): string {
+  try {
+    const filePath = getGslothConfigReadPath(guidelinesFilename);
+    return readFileFromCurrentDir(filePath);
+  } catch (error) {
+    displayError(
       'Consider running `gsloth init` to set up your project. Check `gsloth init --help` to see options.'
-    ) || ''
-  );
+    );
+    throw error;
+  }
+}
+
+export function readReviewInstructions(reviewInstructions: string): string {
+  return readConfigPromptFile(reviewInstructions);
+}
+
+function readConfigPromptFile(guidelinesFilename: string): string {
+  try {
+    const filePath = getGslothConfigReadPath(guidelinesFilename);
+    return readFileFromCurrentOrInstallDir(filePath);
+  } catch (error) {
+    displayError(
+      'Consider running `gsloth init` to set up your project. Check `gsloth init --help` to see options.'
+    );
+    throw error;
+  }
 }
 
 /**

package/src/systemUtils.ts

@@ -1,5 +1,7 @@
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'url';
+import { Command } from 'commander';
+import { ProgressIndicator } from '#src/utils.js';
 
 /**
  * This file contains all system functions and objects that are globally available
@@ -12,10 +14,12 @@ import { fileURLToPath } from 'url';
 
 interface InnerState {
   installDir: string | null | undefined;
+  stringFromStdin: string;
 }
 
 const innerState: InnerState = {
   installDir: undefined,
+  stringFromStdin: '',
 };
 
 // Process-related functions and objects
@@ -26,6 +30,12 @@ export const getInstallDir = (): string => {
   }
   throw new Error('Install directory not set');
 };
+/**
+ * Cached string from stdin. Should only be called after readStdin completes execution.
+ */
+export const getStringFromStdin = (): string => {
+  return innerState.stringFromStdin;
+};
 export const exit = (code?: number): never => process.exit(code || 0);
 export const stdin = process.stdin;
 export const stdout = process.stdout;
@@ -44,6 +54,34 @@ export const setEntryPoint = (indexJs: string): void => {
   innerState.installDir = resolve(dirPath);
 };
 
+/**
+ * Asynchronously reads the stdin and stores it as a string,
+ * it can later be retrieved with getStringFromStdin.
+ */
+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', true);
+
+      stdin.on('readable', function (this: NodeJS.ReadStream) {
+        const chunk = this.read();
+        progressIndicator.indicate();
+        if (chunk !== null) {
+          const chunkStr = chunk.toString('utf8');
+          innerState.stringFromStdin = innerState.stringFromStdin + chunkStr;
+        }
+      });
+
+      stdin.on('end', function () {
+        program.parseAsync(argv).then(() => resolvePromise());
+      });
+    }
+  });
+}
+
 // Console-related functions
 export const log = (message: string): void => console.log(message);
 export const error = (message: string): void => console.error(message);

package/src/utils.ts

@@ -1,36 +1,84 @@
 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 { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { SlothConfig } from '#src/config.js';
+import { resolve, dirname } from 'node:path';
 import { spawn } from 'node:child_process';
-import { exit, stdin, stdout, argv, getCurrentDir, getInstallDir } from '#src/systemUtils.js';
+import { getCurrentDir, getInstallDir, stdout } 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, '-');
 }
 
+/**
+ * Returns a formatted date string in the format YYYY-MM-DD_HH-MM-SS using local time
+ * @returns A formatted date string
+ */
 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);
+
+  // Format: YYYY-MM-DD_HH-MM-SS using local time directly
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const hours = String(date.getHours()).padStart(2, '0');
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  const seconds = String(date.getSeconds()).padStart(2, '0');
+
+  return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}`;
+}
+
+/**
+ * Generates a standardized filename with the format: gth_YYYY-MM-DD_HH-MM-SS_COMMAND.md
+ * @param command - The command that created the file (ASK, REVIEW, PR, etc.)
+ * @returns A standardized filename string
+ */
+export function generateStandardFileName(command: string): string {
+  const dateTimeStr = fileSafeLocalDate();
+  const commandStr = toFileSafeString(command.toUpperCase());
+
+  return `gth_${dateTimeStr}_${commandStr}.md`;
 }
 
 export function readFileFromCurrentDir(fileName: string): string {
   const currentDir = getCurrentDir();
   const filePath = resolve(currentDir, fileName);
-  display(`Reading file ${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)) {
+    // Create parent directories if they don't exist
+    const parentDir = dirname(filePath);
+    if (!existsSync(parentDir)) {
+      mkdirSync(parentDir, { recursive: true });
+    }
     writeFileSync(filePath, content);
     displaySuccess(`Created ${filePath}`);
   } else {
@@ -53,36 +101,10 @@ export function readFileSyncWithMessages(
     } 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
+    throw error;
   }
 }
 
-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;
@@ -95,7 +117,7 @@ export async function spawnCommand(
   successMessage: string
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    const progressIndicator = new ProgressIndicator(progressMessage);
+    const progressIndicator = new ProgressIndicator(progressMessage, true);
     const out: SpawnOutput = { stdout: '', stderr: '' };
     const spawned = spawn(command, args);
 
@@ -134,21 +156,31 @@ export function getSlothVersion(): string {
 }
 
 export class ProgressIndicator {
-  private hasBeenCalled: boolean;
-  private initialMessage: string;
+  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;
+    }
+  }
 
-  constructor(initialMessage: string) {
-    this.hasBeenCalled = false;
-    this.initialMessage = initialMessage;
+  private indicateInner(): void {
+    stdout.write('.');
   }
 
   indicate(): void {
-    if (this.hasBeenCalled) {
-      stdout.write('.');
-    } else {
-      this.hasBeenCalled = true;
-      stdout.write(this.initialMessage);
+    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');
   }
 }
 

package/.gsloth.preamble.review.md

@@ -1,125 +0,0 @@
-You are conducting LangChain.js/LangGraph.js Node.JS code review.
-
-# Code Review Guidelines for LangChain.js/LangGraph.js Projects
-
-## Core Review Principles
-
-### Architecture and Flow
-- Verify proper separation of LangChain components (LLMs, chains, agents, tools)
-- Check for clear data flow between components
-- Ensure proper state management in LangGraph workflows
-- Validate error handling and fallback mechanisms
-
-### Performance Considerations
-- Review chunking strategies for large inputs
-- Check for proper caching implementation
-- Verify memory management for conversation chains
-- Assess streaming implementation where applicable
-
-### Security
-- Validate API key handling and environment variables
-- Make sure no personal data is present in code
-- Check for proper input sanitization
-- Review rate limiting implementation
-- Verify output validation and sanitization
-
-## Technical Checklist
-
-### LangChain.js Specific
-- [ ] Proper chain composition and sequencing
-- [ ] Correct prompt template formatting
-- [ ] Appropriate memory implementation
-- [ ] Tool configuration and validation
-- [ ] Output parser implementation
-- [ ] Model configuration and defaults
-
-### LangGraph.js Specific
-- [ ] State machine definition correctness
-- [ ] Edge case handling in workflows
-- [ ] Proper node transitions
-- [ ] State persistence strategy
-- [ ] Graph visualization implementation (if applicable)
-
-### General Code Quality
-- [ ] TypeScript type definitions
-- [ ] Async/await implementation
-- [ ] Error boundary definition
-- [ ] Logging implementation
-- [ ] Test coverage
-- [ ] Documentation quality
-
-## Best Practices
-
-### Configuration
-Make sure that API keys are accidentally not included into diff.
-
-### Common Pitfalls to Check
-1. Improper chain composition
-2. Missing error handlers
-3. Memory leaks in long-running chains
-4. Incorrect prompt engineering
-5. Inadequate rate limiting
-6. Missing type definitions
-7. Improper streaming implementation
-
-### Performance Optimization Points
-1. Caching strategy
-2. Batch processing implementation
-3. Connection pooling
-4. Resource cleanup
-5. Memory management
-
-## Testing Requirements
-
-### Unit Tests
-- Individual chain components
-- Tool implementations
-- Parser functions
-- State transitions
-
-### Integration Tests
-- End-to-end workflows
-- External API interactions
-- Error scenarios
-- State persistence
-
-### Load Tests
-- Concurrent request handling
-- Memory usage under load
-- Response time benchmarks
-
-## Documentation Requirements
-
-1. Architecture overview
-2. Component interaction diagrams
-3. Configuration guide
-4. API documentation
-5. Error handling guide
-6. Performance optimization guide
-7. Deployment checklist
-
-## Monitoring and Observability
-
-### Metrics to Track
-- Chain execution times
-- Token usage
-- Error rates
-- Memory consumption
-- API latencies
-
-### Logging Requirements
-- Request/response pairs
-- Error stack traces
-- Performance metrics
-- State transitions
-- Resource usage
-
----
-
-Provide specific feedback on any areas of concern or suggestions for improvement. Please categorize your feedback (e.g., "Bug," "Suggestion," "Nitpick").
-
-Important! In the end conclude if you would recommend to approve this PR or not. Use ✅⚠️❌ symbols to highlight your feedback appropriately.
-
-Thank you for your thorough review!
-
-Important! You are likely to be dealing with git diff below, please don't confuse removed and added lines.

package/UX-RESEARCH.md

@@ -1,78 +0,0 @@
-# UX Research
-
-## Currently available commands:
-```
-gsloth --help
-Usage: gsloth [options] [command]
-
-Gaunt Sloth Assistant reviewing your PRs
-
-Options:
-  -V, --version            output the version number
-  -h, --help               display help for command
-
-Commands:
-  init <type>              Initialize the Gaunt Sloth Assistant in your project.
-                           This will write necessary config files.
-  pr [options] <prNumber>  Review a PR in current git directory (assuming that
-                           GH cli is installed and authenticated for current
-                           project
-  review [options]         Review provided diff or other content
-  ask [options] <message>  Ask a question
-  help [command]           display help for command
-```
-
-pr (we decided to rename it to r as shortcut for review with pull request provider)
-```
-gsloth pr --help
-Usage: gsloth pr [options] <prNumber>
-
-Review a PR in current git directory (assuming that GH cli is installed and
-authenticated for current project
-
-Arguments:
-  prNumber           PR number to review
-
-Options:
-  -f, --file <file>  Input file. Content of this file will be added BEFORE the
-                     diff
-  -h, --help         display help for command
-```
-
-ask
-```
-gsloth ask --help
-Usage: gsloth ask [options] <message>
-
-Ask a question
-
-Arguments:
-  message            A message
-
-Options:
-  -f, --file <file>  Input file. Context of this file will be added BEFORE the
-                     diff
-  -h, --help         display help for command
-```
-
-review (lacks documentaion, it also accepts pipe with stdin)
-```
-gsloth review --help
-Usage: gsloth review [options]
-
-Review provided diff or other content
-
-Options:
-  -f, --file <file>  Input file. Context of this file will be added BEFORE the
-                     diff
-  -h, --help         display help for command
-```
-
-## Future functions
-
-- JIRA. We need to privide a jira number as a criteria, this should somehow go through separate provider and using config from .gsloth.config.
-- External links (simple public links)
-- Editing files
-- Improve experience with specs or criteria (or requirements?)
-- Should we allow to mention that the data is diff or plain code? Maybe we can somehow deduct it or ask smaller model to guess?
-- Slot editing local files