@positronic/cli 0.0.3 → 0.0.4

package/src/commands/brain.ts

@@ -1,215 +0,0 @@
-import type { ArgumentsCamelCase } from 'yargs';
-import { apiClient } from './helpers.js';
-import React from 'react';
-import { Text } from 'ink';
-import { Watch } from '../components/watch.js';
-import { BrainList } from '../components/brain-list.js';
-import { BrainHistory } from '../components/brain-history.js';
-import { BrainShow } from '../components/brain-show.js';
-import { BrainRerun } from '../components/brain-rerun.js';
-import { ErrorComponent } from '../components/error.js';
-
-interface BrainListArgs {}
-interface BrainHistoryArgs {
-  name: string;
-  limit: number;
-}
-interface BrainShowArgs {
-  name: string;
-}
-interface BrainRerunArgs {
-  name: string;
-  runId?: string;
-  startsAt?: number;
-  stopsAfter?: number;
-}
-interface BrainRunArgs {
-  name: string;
-  watch?: boolean;
-}
-interface BrainWatchArgs {
-  runId?: string;
-  name?: string;
-}
-
-export class BrainCommand {
-  list(argv: ArgumentsCamelCase<BrainListArgs>): React.ReactElement {
-    return React.createElement(BrainList);
-  }
-
-  history({
-    name: brainName,
-    limit,
-  }: ArgumentsCamelCase<BrainHistoryArgs>): React.ReactElement {
-    return React.createElement(BrainHistory, { brainName, limit });
-  }
-
-  show({
-    name: brainName,
-  }: ArgumentsCamelCase<BrainShowArgs>): React.ReactElement {
-    return React.createElement(BrainShow, { brainName });
-  }
-
-  rerun({
-    name: brainName,
-    runId,
-    startsAt,
-    stopsAfter,
-  }: ArgumentsCamelCase<BrainRerunArgs>): React.ReactElement {
-    return React.createElement(BrainRerun, {
-      brainName,
-      runId,
-      startsAt,
-      stopsAfter,
-    });
-  }
-
-  async run({ name: brainName, watch }: ArgumentsCamelCase<BrainRunArgs>): Promise<React.ReactElement> {
-    const apiPath = '/brains/runs';
-    try {
-      const response = await apiClient.fetch(apiPath, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ brainName }),
-      });
-
-      if (response.status === 201) {
-        const result = (await response.json()) as { brainRunId: string };
-
-        if (watch) {
-          // Return Watch component for CLI to render
-          return this.watch({
-            runId: result.brainRunId,
-            _: [],
-            $0: '',
-          });
-        } else {
-          // Return React element displaying the run ID
-          return React.createElement(
-            Text,
-            null,
-            `Run ID: ${result.brainRunId}`
-          );
-        }
-      } else if (response.status === 404) {
-        // Handle brain not found with a helpful message
-        return React.createElement(ErrorComponent, {
-          error: {
-            title: 'Brain Not Found',
-            message: `Brain '${brainName}' not found.`,
-            details: 'Please check that:\n  1. The brain name is spelled correctly\n  2. The brain exists in your project\n  3. The brain has been properly defined and exported\n\nYou can list available brains with: positronic list'
-          }
-        });
-      } else {
-        const errorText = await response.text();
-        console.error(
-          `Error starting brain run: ${response.status} ${response.statusText}`
-        );
-        console.error(`Server response: ${errorText}`);
-        process.exit(1);
-      }
-    } catch (error: any) {
-      console.error(`Error connecting to the local development server.`);
-      console.error(
-        "Please ensure the server is running ('positronic server' or 'px s')."
-      );
-      if (error.code === 'ECONNREFUSED') {
-        console.error(
-          'Reason: Connection refused. The server might not be running or is listening on a different port.'
-        );
-      } else {
-        console.error(`Fetch error details: ${error.message}`);
-      }
-      process.exit(1);
-    }
-  }
-
-  async watch({
-    runId,
-    name: brainName,
-  }: ArgumentsCamelCase<BrainWatchArgs>): Promise<React.ReactElement> {
-    // If a specific run ID is provided, return the Watch component
-    if (runId) {
-      const port = process.env.POSITRONIC_PORT || '8787';
-      return React.createElement(Watch, { runId, port });
-    }
-
-    // If watching by brain name is requested, look up active runs
-    if (brainName) {
-      try {
-        const apiPath = `/brains/${encodeURIComponent(brainName)}/active-runs`;
-        const response = await apiClient.fetch(apiPath, {
-          method: 'GET',
-        });
-
-        if (response.status === 200) {
-          const result = await response.json() as { runs: Array<{ brainRunId: string; brainTitle: string; status: string; createdAt: number }> };
-          
-          if (result.runs.length === 0) {
-            return React.createElement(
-              ErrorComponent,
-              {
-                error: {
-                  title: 'No Active Runs',
-                  message: `No currently running brain runs found for brain "${brainName}".`,
-                  details: `To start a new run, use: positronic run ${brainName}`
-                }
-              }
-            );
-          }
-
-          if (result.runs.length > 1) {
-            return React.createElement(
-              ErrorComponent,
-              {
-                error: {
-                  title: 'Multiple Active Runs',
-                  message: `Found ${result.runs.length} active runs for brain "${brainName}".`,
-                  details: `Please specify a specific run ID with --run-id:\n${result.runs.map(run => `  positronic watch --run-id ${run.brainRunId}`).join('\n')}`
-                }
-              }
-            );
-          }
-
-          // Exactly one active run found - watch it
-          const activeRun = result.runs[0];
-          const port = process.env.POSITRONIC_PORT || '8787';
-          return React.createElement(Watch, { runId: activeRun.brainRunId, port });
-        } else {
-          const errorText = await response.text();
-          return React.createElement(
-            ErrorComponent,
-            {
-              error: {
-                title: 'API Error',
-                message: `Failed to get active runs for brain "${brainName}".`,
-                details: `Server returned ${response.status}: ${errorText}`
-              }
-            }
-          );
-        }
-      } catch (error: any) {
-        return React.createElement(
-          ErrorComponent,
-          {
-            error: {
-              title: 'Connection Error',
-              message: 'Error connecting to the local development server.',
-              details: `Please ensure the server is running ('positronic server' or 'px s').\n\nError details: ${error.message}`
-            }
-          }
-        );
-      }
-    }
-
-    // Neither runId nor brainName provided – return an error element.
-    return React.createElement(
-      Text,
-      { color: 'red' as any }, // Ink Text color prop
-      'Error: You must provide either a brain run ID or a brain name.'
-    );
-  }
-
-}

package/src/commands/helpers.test.ts

@@ -1,487 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { Response } from 'node-fetch';
-import { syncResources, generateTypes } from './helpers.js';
-import { createMockApiClient } from '../test/mock-api-client.js';
-
-describe('Helper Functions Unit Tests', () => {
-  let tempDir: string;
-  let projectPath: string;
-  let mockClient: ReturnType<typeof createMockApiClient>;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'positronic-unit-test-'));
-    projectPath = path.join(tempDir, 'test-project');
-    fs.mkdirSync(projectPath, { recursive: true });
-    mockClient = createMockApiClient();
-  });
-
-  afterEach(() => {
-    fs.rmSync(tempDir, { recursive: true, force: true });
-    mockClient.reset();
-  });
-
-  describe('syncResources', () => {
-    it('should create resources directory if it does not exist', async () => {
-      const resourcesDir = path.join(projectPath, 'resources');
-      expect(fs.existsSync(resourcesDir)).toBe(false);
-
-      await syncResources(projectPath, mockClient);
-
-      expect(fs.existsSync(resourcesDir)).toBe(true);
-    });
-
-    it('should return zero counts for empty resources directory', async () => {
-      const resourcesDir = path.join(projectPath, 'resources');
-      fs.mkdirSync(resourcesDir, { recursive: true });
-
-      const result = await syncResources(projectPath, mockClient);
-
-      expect(result).toEqual({
-        uploadCount: 0,
-        skipCount: 0,
-        errorCount: 0,
-        totalCount: 0,
-        deleteCount: 0,
-        errors: [],
-      });
-
-      // Should not make any API calls for empty directory
-      expect(mockClient.calls.length).toBe(1); // Only GET /resources call
-    });
-
-    it('should upload new resources', async () => {
-      const resourcesDir = path.join(projectPath, 'resources');
-      fs.mkdirSync(resourcesDir, { recursive: true });
-
-      // Create test files
-      fs.writeFileSync(path.join(resourcesDir, 'test.txt'), 'Hello World');
-      fs.writeFileSync(
-        path.join(resourcesDir, 'data.json'),
-        '{"key": "value"}'
-      );
-
-      const result = await syncResources(projectPath, mockClient);
-
-      expect(result.uploadCount).toBe(2);
-      expect(result.skipCount).toBe(0);
-      expect(result.errorCount).toBe(0);
-      expect(result.totalCount).toBe(2);
-
-      // Verify API calls
-      expect(mockClient.calls).toHaveLength(3); // 1 GET + 2 POSTs
-      expect(mockClient.calls[0].path).toBe('/resources');
-      expect(mockClient.calls[1].path).toBe('/resources');
-      expect(mockClient.calls[1].options?.method).toBe('POST');
-
-      // Verify uploaded resources
-      const resources = mockClient.getResources();
-      expect(resources).toHaveLength(2);
-      expect(resources.find((r) => r.key === 'test.txt')).toBeDefined();
-      expect(resources.find((r) => r.key === 'data.json')).toBeDefined();
-    });
-
-    it('should skip unchanged resources', async () => {
-      const resourcesDir = path.join(projectPath, 'resources');
-      fs.mkdirSync(resourcesDir, { recursive: true });
-
-      // Add existing resource to mock with future lastModified to ensure it's newer than the file
-      mockClient.addResource({
-        key: 'existing.txt',
-        type: 'text',
-        size: 8,
-        lastModified: new Date(Date.now() + 10000).toISOString(), // 10 seconds in the future
-        local: false, // Default to false for existing tests
-      });
-
-      // Create matching file
-      fs.writeFileSync(path.join(resourcesDir, 'existing.txt'), '12345678'); // 8 bytes
-
-      const result = await syncResources(projectPath, mockClient);
-
-      expect(result.uploadCount).toBe(0);
-      expect(result.skipCount).toBe(1);
-      expect(result.errorCount).toBe(0);
-
-      // Should only make GET call
-      expect(mockClient.calls).toHaveLength(1);
-      expect(mockClient.calls[0].path).toBe('/resources');
-    });
-
-    it('should upload modified resources based on size', async () => {
-      const resourcesDir = path.join(projectPath, 'resources');
-      fs.mkdirSync(resourcesDir, { recursive: true });
-
-      // Add existing resource to mock with different size
-      mockClient.addResource({
-        key: 'modified.txt',
-        type: 'text',
-        size: 5,
-        lastModified: new Date(Date.now() - 10000).toISOString(),
-        local: false, // Default to false for existing tests
-      });
-
-      // Create file with different content
-      fs.writeFileSync(path.join(resourcesDir, 'modified.txt'), 'New content');
-
-      const result = await syncResources(projectPath, mockClient);
-
-      expect(result.uploadCount).toBe(1);
-      expect(result.skipCount).toBe(0);
-    });
-
-    it('should upload resources based on modification time when size matches', async () => {
-      const resourcesDir = path.join(projectPath, 'resources');
-      fs.mkdirSync(resourcesDir, { recursive: true });
-
-      // Add existing resource to mock with same size but older timestamp
-      mockClient.addResource({
-        key: 'updated.txt',
-        type: 'text',
-        size: 11, // Same size as "Same content"
-        lastModified: new Date(Date.now() - 10000).toISOString(), // 10 seconds ago
-        local: false, // Default to false for existing tests
-      });
-
-      // Create file with same size but it will have a newer modification time
-      fs.writeFileSync(path.join(resourcesDir, 'updated.txt'), 'Same content'); // 11 bytes
-
-      const result = await syncResources(projectPath, mockClient);
-
-      expect(result.uploadCount).toBe(1);
-      expect(result.skipCount).toBe(0);
-    });
-
-    it('should handle nested directories', async () => {
-      const resourcesDir = path.join(projectPath, 'resources');
-      const docsDir = path.join(resourcesDir, 'docs');
-      fs.mkdirSync(docsDir, { recursive: true });
-
-      fs.writeFileSync(path.join(docsDir, 'readme.md'), '# README');
-
-      const result = await syncResources(projectPath, mockClient);
-
-      expect(result.uploadCount).toBe(1);
-
-      const resources = mockClient.getResources();
-      expect(resources[0].key).toBe('docs/readme.md');
-    });
-
-    it('should handle upload errors gracefully', async () => {
-      const resourcesDir = path.join(projectPath, 'resources');
-      fs.mkdirSync(resourcesDir, { recursive: true });
-
-      // Create a file that will trigger an error in our mock
-      // We'll modify the mock to fail on specific file names
-      const badClient = createMockApiClient();
-      const originalFetch = badClient.fetch;
-      badClient.fetch = async (path, options) => {
-        if (
-          options?.method === 'POST' &&
-          options.body instanceof FormData &&
-          options.body.get('key') === 'error.txt'
-        ) {
-          throw new Error('Upload failed');
-        }
-        return originalFetch.call(badClient, path, options);
-      };
-
-      fs.writeFileSync(path.join(resourcesDir, 'error.txt'), 'This will fail');
-      fs.writeFileSync(
-        path.join(resourcesDir, 'good.txt'),
-        'This will succeed'
-      );
-
-      const result = await syncResources(projectPath, badClient);
-
-      expect(result.uploadCount).toBe(1);
-      expect(result.errorCount).toBe(1);
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0]).toEqual({
-        file: 'error.txt',
-        message: 'Upload failed',
-      });
-    });
-
-    it('should delete server resources with local=true when files are removed', async () => {
-      const resourcesDir = path.join(projectPath, 'resources');
-      fs.mkdirSync(resourcesDir, { recursive: true });
-
-      // Create the file that should still exist first
-      fs.writeFileSync(
-        path.join(resourcesDir, 'still-exists.txt'),
-        'I still exist'
-      );
-
-      // Add existing resources to mock - some synced (local=true), some manual (local=false)
-      mockClient.addResource({
-        key: 'deleted-file.txt',
-        type: 'text',
-        size: 100,
-        lastModified: new Date().toISOString(),
-        local: true, // This one should be deleted
-      });
-      mockClient.addResource({
-        key: 'still-exists.txt',
-        type: 'text',
-        size: 13, // Exact size of "I still exist"
-        lastModified: new Date(Date.now() + 10000).toISOString(), // Future timestamp to prevent re-upload
-        local: true, // This one should NOT be deleted
-      });
-      mockClient.addResource({
-        key: 'docs/removed-doc.md',
-        type: 'text',
-        size: 200,
-        lastModified: new Date().toISOString(),
-        local: true, // This one should be deleted
-      });
-
-      const result = await syncResources(projectPath, mockClient);
-
-      expect(result.deleteCount).toBe(2);
-      expect(result.uploadCount).toBe(0); // No new uploads
-      expect(result.skipCount).toBe(1); // still-exists.txt is up to date
-
-      // Verify the correct resources were deleted
-      const remainingResources = mockClient.getResources();
-      expect(remainingResources).toHaveLength(1);
-      expect(remainingResources[0].key).toBe('still-exists.txt');
-
-      // Verify DELETE API calls were made
-      const deleteCalls = mockClient.calls.filter(
-        (call) => call.options?.method === 'DELETE'
-      );
-      expect(deleteCalls).toHaveLength(2);
-      expect(deleteCalls[0].path).toBe('/resources/deleted-file.txt');
-      expect(deleteCalls[1].path).toBe('/resources/docs%2Fremoved-doc.md'); // URL encoded
-    });
-
-    it('should preserve manually uploaded resources (local=false)', async () => {
-      const resourcesDir = path.join(projectPath, 'resources');
-      fs.mkdirSync(resourcesDir, { recursive: true });
-
-      // Add existing resources to mock
-      mockClient.addResource({
-        key: 'manual-upload.txt',
-        type: 'text',
-        size: 100,
-        lastModified: new Date().toISOString(),
-        local: false, // Manually uploaded - should NOT be deleted
-      });
-      mockClient.addResource({
-        key: 'another-manual.png',
-        type: 'binary',
-        size: 5000,
-        lastModified: new Date().toISOString(),
-        local: false, // Manually uploaded - should NOT be deleted
-      });
-      mockClient.addResource({
-        key: 'synced-file.txt',
-        type: 'text',
-        size: 75,
-        lastModified: new Date().toISOString(),
-        local: true, // Synced file that was deleted locally
-      });
-
-      // Don't create any local files - all are "deleted" locally
-
-      const result = await syncResources(projectPath, mockClient);
-
-      expect(result.deleteCount).toBe(1); // Only the synced file
-      expect(result.uploadCount).toBe(0);
-      expect(result.skipCount).toBe(0);
-
-      // Verify manual uploads are still there
-      const remainingResources = mockClient.getResources();
-      expect(remainingResources).toHaveLength(2);
-      expect(
-        remainingResources.find((r) => r.key === 'manual-upload.txt')
-      ).toBeDefined();
-      expect(
-        remainingResources.find((r) => r.key === 'another-manual.png')
-      ).toBeDefined();
-      expect(
-        remainingResources.find((r) => r.key === 'synced-file.txt')
-      ).toBeUndefined();
-
-      // Verify only one DELETE call was made
-      const deleteCalls = mockClient.calls.filter(
-        (call) => call.options?.method === 'DELETE'
-      );
-      expect(deleteCalls).toHaveLength(1);
-      expect(deleteCalls[0].path).toBe('/resources/synced-file.txt');
-    });
-
-    it('should handle delete errors gracefully', async () => {
-      const resourcesDir = path.join(projectPath, 'resources');
-      fs.mkdirSync(resourcesDir, { recursive: true });
-
-      // Create a client that fails on DELETE requests
-      const badClient = createMockApiClient();
-      badClient.addResource({
-        key: 'will-fail-delete.txt',
-        type: 'text',
-        size: 100,
-        lastModified: new Date().toISOString(),
-        local: true,
-      });
-
-      const originalFetch = badClient.fetch;
-      badClient.fetch = (async (path: string, options?: RequestInit) => {
-        if (options?.method === 'DELETE') {
-          return new Response('Internal Server Error', { status: 500 });
-        }
-        return originalFetch.call(badClient, path, options);
-      }) as typeof badClient.fetch;
-
-      // Don't create the file locally so it should be deleted
-
-      const result = await syncResources(projectPath, badClient);
-
-      expect(result.deleteCount).toBe(0); // Failed to delete
-      expect(result.errorCount).toBe(1);
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0]).toEqual({
-        file: 'will-fail-delete.txt',
-        message: 'Failed to delete: Delete failed: 500 Internal Server Error',
-      });
-    });
-  });
-
-  describe('generateTypes', () => {
-    it('should generate types file for empty resources', async () => {
-      const result = await generateTypes(projectPath, mockClient);
-
-      const typesPath = path.join(projectPath, 'resources.d.ts');
-      expect(fs.existsSync(typesPath)).toBe(true);
-
-      const content = fs.readFileSync(typesPath, 'utf-8');
-      expect(content).toContain("declare module '@positronic/core'");
-      expect(content).toContain('interface Resources');
-      expect(content).toContain('loadText(path: string): Promise<string>');
-      expect(content).toContain('loadBinary(path: string): Promise<Buffer>');
-    });
-
-    it('should generate types for text and binary resources', async () => {
-      // Add mock resources
-      mockClient.addResource({
-        key: 'readme.md',
-        type: 'text',
-        size: 100,
-        lastModified: new Date().toISOString(),
-        local: false, // Default to false for existing tests
-      });
-      mockClient.addResource({
-        key: 'logo.png',
-        type: 'binary',
-        size: 1000,
-        lastModified: new Date().toISOString(),
-        local: false, // Default to false for existing tests
-      });
-      mockClient.addResource({
-        key: 'data.json',
-        type: 'text',
-        size: 50,
-        lastModified: new Date().toISOString(),
-        local: false, // Default to false for existing tests
-      });
-
-      await generateTypes(projectPath, mockClient);
-
-      const typesPath = path.join(projectPath, 'resources.d.ts');
-      const content = fs.readFileSync(typesPath, 'utf-8');
-
-      // Check resource declarations
-      expect(content).toContain('readme: TextResource;');
-      expect(content).toContain('logo: BinaryResource;');
-      expect(content).toContain('data: TextResource;');
-    });
-
-    it('should handle nested resources', async () => {
-      mockClient.addResource({
-        key: 'docs/api.md',
-        type: 'text',
-        size: 100,
-        lastModified: new Date().toISOString(),
-        local: false, // Default to false for existing tests
-      });
-      mockClient.addResource({
-        key: 'docs/images/diagram.png',
-        type: 'binary',
-        size: 500,
-        lastModified: new Date().toISOString(),
-        local: false, // Default to false for existing tests
-      });
-      mockClient.addResource({
-        key: 'config/settings.json',
-        type: 'text',
-        size: 200,
-        lastModified: new Date().toISOString(),
-        local: false, // Default to false for existing tests
-      });
-
-      await generateTypes(projectPath, mockClient);
-
-      const typesPath = path.join(projectPath, 'resources.d.ts');
-      const content = fs.readFileSync(typesPath, 'utf-8');
-
-      // Check nested structure
-      expect(content).toContain('docs: {');
-      expect(content).toContain('api: TextResource;');
-      expect(content).toContain('images: {');
-      expect(content).toContain('diagram: BinaryResource;');
-      expect(content).toContain('config: {');
-      expect(content).toContain('settings: TextResource;');
-    });
-
-    it('should exclude invalid JavaScript identifiers', async () => {
-      mockClient.addResource({
-        key: '123invalid.txt',
-        type: 'text',
-        size: 100,
-        lastModified: new Date().toISOString(),
-        local: false, // Default to false for existing tests
-      });
-      mockClient.addResource({
-        key: 'file-with-dash.txt',
-        type: 'text',
-        size: 100,
-        lastModified: new Date().toISOString(),
-        local: false, // Default to false for existing tests
-      });
-      mockClient.addResource({
-        key: 'valid_file.txt',
-        type: 'text',
-        size: 100,
-        lastModified: new Date().toISOString(),
-        local: false, // Default to false for existing tests
-      });
-
-      await generateTypes(projectPath, mockClient);
-
-      const typesPath = path.join(projectPath, 'resources.d.ts');
-      const content = fs.readFileSync(typesPath, 'utf-8');
-
-      // Should include valid identifier
-      expect(content).toContain('valid_file: TextResource;');
-
-      // Should not include invalid identifiers
-      expect(content).not.toContain('123invalid');
-      expect(content).not.toContain('file-with-dash');
-    });
-
-    it('should handle API errors gracefully', async () => {
-      // Create a client that returns an error
-      const errorClient = createMockApiClient();
-      errorClient.fetch = (async (path: string, options?: RequestInit) => {
-        return new Response('Internal Server Error', { status: 500 });
-      }) as any;
-
-      await expect(generateTypes(projectPath, errorClient)).rejects.toThrow(
-        'Failed to fetch resources: 500 Internal Server Error'
-      );
-    });
-  });
-});