@bernierllc/braingrid-cli-wrapper 0.1.1

package/src/models.test.ts

@@ -0,0 +1,197 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+import {
+  BrainGridProjectSchema,
+  BrainGridRequirementSchema,
+  BrainGridTaskSchema,
+  RequirementStatus,
+  TaskStatus,
+  BrainGridCliError
+} from './models';
+
+describe('BrainGrid Schemas', () => {
+  describe('BrainGridProjectSchema', () => {
+    it('should validate a valid project', () => {
+      const validProject = {
+        id: 'proj-123',
+        name: 'Test Project',
+        description: 'A test project'
+      };
+
+      const result = BrainGridProjectSchema.safeParse(validProject);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.id).toBe('proj-123');
+        expect(result.data.name).toBe('Test Project');
+      }
+    });
+
+    it('should reject invalid project', () => {
+      const invalidProject = {
+        id: 123, // Should be string
+        name: 'Test'
+      };
+
+      const result = BrainGridProjectSchema.safeParse(invalidProject);
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('BrainGridRequirementSchema', () => {
+    it('should validate a valid requirement', () => {
+      const validReq = {
+        id: 'req-456',
+        projectId: 'proj-123',
+        title: 'Add authentication',
+        status: 'IDEA' as RequirementStatus,
+        description: 'Add OAuth2 auth'
+      };
+
+      const result = BrainGridRequirementSchema.safeParse(validReq);
+      expect(result.success).toBe(true);
+    });
+
+    it('should accept all valid statuses', () => {
+      const statuses: RequirementStatus[] = ['IDEA', 'PLANNED', 'IN_PROGRESS', 'COMPLETED', 'CANCELLED', 'PAUSED'];
+
+      statuses.forEach(status => {
+        const req = {
+          id: 'req-456',
+          projectId: 'proj-123',
+          title: 'Test',
+          status
+        };
+        const result = BrainGridRequirementSchema.safeParse(req);
+        expect(result.success).toBe(true);
+      });
+    });
+
+    it('should reject invalid requirement status', () => {
+      const invalidReq = {
+        id: 'req-456',
+        projectId: 'proj-123',
+        title: 'Test',
+        status: 'INVALID_STATUS'
+      };
+
+      const result = BrainGridRequirementSchema.safeParse(invalidReq);
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('BrainGridTaskSchema', () => {
+    it('should validate a valid task', () => {
+      const validTask = {
+        id: 'task-789',
+        reqId: 'req-456',
+        title: 'Build login UI',
+        status: 'TODO' as TaskStatus,
+        tags: ['DEV', 'frontend'],
+        dependencies: ['task-123', 'task-456']
+      };
+
+      const result = BrainGridTaskSchema.safeParse(validTask);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.tags).toHaveLength(2);
+        expect(result.data.dependencies).toHaveLength(2);
+      }
+    });
+
+    it('should allow optional fields to be undefined', () => {
+      const minimalTask = {
+        id: 'task-789',
+        reqId: 'req-456',
+        title: 'Build login UI',
+        status: 'TODO' as TaskStatus
+      };
+
+      const result = BrainGridTaskSchema.safeParse(minimalTask);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.tags).toBeUndefined();
+        expect(result.data.dependencies).toBeUndefined();
+      }
+    });
+
+    it('should reject invalid task status', () => {
+      const invalidTask = {
+        id: 'task-789',
+        reqId: 'req-456',
+        title: 'Build login UI',
+        status: 'INVALID_STATUS'
+      };
+
+      const result = BrainGridTaskSchema.safeParse(invalidTask);
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('BrainGridCliError', () => {
+    it('should create error with all properties', () => {
+      const error = new BrainGridCliError(
+        'Command failed',
+        'braingrid test-command',
+        1,
+        'Error output from stderr'
+      );
+
+      expect(error).toBeInstanceOf(Error);
+      expect(error.name).toBe('BrainGridCliError');
+      expect(error.message).toBe('Command failed');
+      expect(error.command).toBe('braingrid test-command');
+      expect(error.exitCode).toBe(1);
+      expect(error.stderr).toBe('Error output from stderr');
+    });
+
+    it('should preserve error properties when thrown', () => {
+      try {
+        throw new BrainGridCliError(
+          'Test error',
+          'braingrid fail',
+          2,
+          'stderr content'
+        );
+      } catch (err) {
+        expect(err).toBeInstanceOf(BrainGridCliError);
+        if (err instanceof BrainGridCliError) {
+          expect(err.message).toBe('Test error');
+          expect(err.command).toBe('braingrid fail');
+          expect(err.exitCode).toBe(2);
+          expect(err.stderr).toBe('stderr content');
+        }
+      }
+    });
+
+    it('should handle empty stderr', () => {
+      const error = new BrainGridCliError(
+        'Command failed',
+        'braingrid cmd',
+        1,
+        ''
+      );
+
+      expect(error.stderr).toBe('');
+      expect(error.exitCode).toBe(1);
+    });
+
+    it('should handle different exit codes', () => {
+      const exitCodes = [0, 1, 2, 127, 255];
+
+      exitCodes.forEach(code => {
+        const error = new BrainGridCliError(
+          'Test',
+          'cmd',
+          code,
+          'stderr'
+        );
+        expect(error.exitCode).toBe(code);
+      });
+    });
+  });
+});

package/src/models.ts

@@ -0,0 +1,93 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { z } from 'zod';
+
+// Requirement statuses
+export const RequirementStatusSchema = z.enum([
+  'IDEA',
+  'PLANNED',
+  'IN_PROGRESS',
+  'COMPLETED',
+  'CANCELLED',
+  'PAUSED'
+]);
+
+export type RequirementStatus = z.infer<typeof RequirementStatusSchema>;
+
+// Task statuses
+export const TaskStatusSchema = z.enum([
+  'TODO',
+  'READY',
+  'BLOCKED',
+  'IN_PROGRESS',
+  'COMPLETED',
+  'FAILED',
+  'PAUSED'
+]);
+
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+
+// BrainGrid Project
+export const BrainGridProjectSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional()
+});
+
+export type BrainGridProject = z.infer<typeof BrainGridProjectSchema>;
+
+// BrainGrid Requirement
+export const BrainGridRequirementSchema = z.object({
+  id: z.string(),
+  projectId: z.string(),
+  title: z.string(),
+  status: RequirementStatusSchema,
+  description: z.string().optional(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional()
+});
+
+export type BrainGridRequirement = z.infer<typeof BrainGridRequirementSchema>;
+
+// BrainGrid Task
+export const BrainGridTaskSchema = z.object({
+  id: z.string(),
+  reqId: z.string(),
+  title: z.string(),
+  status: TaskStatusSchema,
+  description: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  dependencies: z.array(z.string()).optional(),
+  assignedTo: z.string().optional(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+  metadata: z.record(z.unknown()).optional()
+});
+
+export type BrainGridTask = z.infer<typeof BrainGridTaskSchema>;
+
+// CLI Error
+export class BrainGridCliError extends Error {
+  public command: string;
+  public exitCode: number;
+  public stderr: string;
+
+  constructor(
+    message: string,
+    command: string,
+    exitCode: number,
+    stderr: string
+  ) {
+    super(message);
+    this.name = 'BrainGridCliError';
+    this.command = command;
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}