Fixing linting issues, unit tests, and integration tests.

Author: adrianwebb

.husky/pre-commit

@@ -1 +1 @@
-npm run format:check && npm run lint && npm run build && npm run test:unit
+npm run format:check && npm run lint && npm run build && npm run test

src/agents/DeveloperAgent.ts

@@ -71,10 +71,11 @@ export class DeveloperAgent {
       // Optional: Git Commit
       if (this.git) {
         try {
+          this.host.log('debug', `[DEBUG DeveloperAgent] Attempting git commit in ${this.project.paths.root}`);
           this.git.add('.');
           this.git.commit(`[nexical] Completed task: ${task.id} - ${task.message}`);
         } catch (e) {
-          this.host.log('warn', `Git commit failed for task ${task.id}: ${e instanceof Error ? e.message : String(e)}`);
+          this.host.log('warn', `Git commit failed for task ${task.id}: ${(e as Error).message}`);
           // We don't fail the whole workflow just because git failed
         }
       }

src/agents/PlannerAgent.ts

@@ -67,9 +67,10 @@ export class PlannerAgent {
     try {
       const plan = Plan.fromYaml(planStr);
       await this.workspace.savePlan(plan);
-    } catch (e: any) {
-      this.host.log('error', `Failed to parse plan YAML: ${e.message}\nContent: ${planStr}`);
-      throw e;
+    } catch (e) {
+      const error = e instanceof Error ? e : new Error(String(e));
+      this.host.log('error', `Failed to parse plan YAML: ${error.message}\nContent: ${planStr}`);
+      throw error;
     }
 
     // Reload plan

src/domain/Plan.ts

@@ -32,7 +32,9 @@ export class Plan {
   static fromYaml(yamlString: string): Plan {
     const data = yaml.load(yamlString);
     const validated = PlanSchema.parse(data);
-    const tasks = validated.tasks.map((t: unknown) => Task.fromData(t));
-    return new Plan(validated.plan_name, tasks);
+    return new Plan(
+      validated.plan_name,
+      validated.tasks.map((t: unknown) => Task.fromData(t)),
+    );
   }
 }

src/domain/Project.ts

@@ -84,6 +84,7 @@ export class Project implements IProject {
 }
 
 class ProjectPaths {
+  public readonly root: string;
   public readonly ai: string;
   public readonly config: string;
   public readonly state: string;
@@ -109,6 +110,7 @@ class ProjectPaths {
   public readonly archive: string;
 
   constructor(root: string) {
+    this.root = root;
     this.ai = path.join(root, '.ai');
     this.config = path.join(this.ai, 'config.yml');
     this.state = path.join(this.ai, 'state.yml');

src/domain/State.ts

@@ -26,6 +26,7 @@ export class EngineState {
   public user_prompt: string = '';
   public interactive: boolean = false;
   public context: Record<string, unknown> = {};
+  public error?: string;
 
   constructor(session_id: string) {
     this.session_id = session_id;
@@ -105,6 +106,7 @@ export class EngineState {
     state.user_prompt = (data.user_prompt as string) || '';
     state.interactive = (data.interactive as boolean) || false;
     state.context = (data.context as Record<string, unknown>) || {};
+    state.error = data.error as string | undefined;
 
     return state;
   }

src/services/GitService.ts

@@ -12,8 +12,10 @@ export class GitService {
   }
 
   runCommand(args: string[], cwd?: string): string {
+    const finalCwd = cwd || this.rootDirectory;
+    this.host.log('debug', `[DEBUG GitService] Executing: git ${args.join(' ')} in ${finalCwd}`);
     const result = this.shell.executeSync('git', args, {
-      cwd: cwd || this.rootDirectory,
+      cwd: finalCwd,
     });
 
     if (result.code !== 0) {

src/services/SkillRunner.ts

@@ -79,16 +79,28 @@ export class SkillRunner implements ISkillRunner {
           continue;
         }
 
-        if (!(await driver.validateSkill(skill))) {
-          errors.push(`Skill '${name}' failed validation for driver '${driver.name}'.`);
+        // Start of the change
+        if (driver) {
+          const valid = await driver.validateSkill(skill);
+          this.host.log('debug', `[DEBUG SkillRunner] Validating ${skill.name} with ${driver.name}: ${valid}`);
+          if (!valid) {
+            errors.push(
+              `Skill '${name}' failed validation for driver '${driver.name}': Driver reported incompatibility.`,
+            );
+          }
+        } else {
+          this.host.log('debug', `[DEBUG SkillRunner] No driver found for provider ${skill.provider}`);
         }
+        // End of the change
       } catch (_e) {
         errors.push(`Error validating skill '${name}': ${(_e as Error).message}`);
       }
     }
 
     if (errors.length > 0) {
-      throw new Error(`Skill validation failed:\n${errors.map((e) => `- ${e}`).join('\n')}`);
+      const msg = `Skill validation failed:\n${errors.map((e) => `- ${e}`).join('\n')}`;
+      this.host.log('error', `[DEBUG SkillRunner] Throwing: ${msg}`);
+      throw new Error(msg);
     }
 
     this.host.log('debug', `Validated ${Object.keys(this.skills).length} skills successfully.`);

src/workflow/Workflow.ts

@@ -112,6 +112,7 @@ export class Workflow {
       if (signal.type === SignalType.FAIL) {
         this.host.log('error', `Workflow Failed: ${signal.reason}`);
         state.updateStatus('FAILED');
+        state.error = signal.reason;
         await this.workspace.saveState(state);
         break;
       }

src/workflow/states/ExecutingState.ts

@@ -1,6 +1,6 @@
 import { EngineState } from '../../domain/State.js';
 import { SignalDetectedError } from '../../errors/SignalDetectedError.js';
-import { Signal } from '../Signal.js';
+import { Signal, SignalType } from '../Signal.js';
 import { State } from './State.js';
 
 export class ExecutingState extends State {
@@ -17,6 +17,29 @@ export class ExecutingState extends State {
       if (error instanceof SignalDetectedError) {
         return error.signal;
       }
+
+      // Fallback for cases where instanceof might fail (ESM/Jest quirks)
+      const errObj = error as Record<string, unknown>;
+
+      if (errObj && typeof errObj === 'object') {
+        if (errObj.code === 'SIGNAL_DETECTED' && errObj.signal) {
+          return errObj.signal as Signal;
+        }
+      }
+
+      const metadata = (errObj?.metadata || {}) as Record<string, unknown>;
+      const rawSignal = (errObj?.signal || metadata.signal) as Record<string, unknown> | undefined;
+
+      if (errObj && typeof errObj === 'object' && (errObj.code === 'SIGNAL_DETECTED' || rawSignal)) {
+        if (rawSignal && typeof rawSignal.type === 'string') {
+          return new Signal(
+            rawSignal.type as SignalType,
+            (rawSignal.reason as string) || '',
+            (rawSignal.metadata as Record<string, unknown>) || {},
+          );
+        }
+        return Signal.fail('Signal detected but missing signal object or type');
+      }
       return Signal.fail(`Execution failed: ${(error as Error).message}`);
     }
   }