@positronic/cli 0.0.2 → 0.0.4

package/src/components/brain-history.tsx

@@ -1,198 +0,0 @@
-import React from 'react';
-import { Text, Box } from 'ink';
-import { useApiGet } from '../hooks/useApi.js';
-import { ErrorComponent } from './error.js';
-
-interface BrainHistoryProps {
-  brainName: string;
-  limit: number;
-}
-
-interface BrainRun {
-  brainRunId: string;
-  brainTitle: string;
-  brainDescription?: string;
-  type: string;
-  status: 'PENDING' | 'RUNNING' | 'COMPLETE' | 'ERROR';
-  options?: any;
-  error?: any;
-  createdAt: number;
-  startedAt?: number;
-  completedAt?: number;
-}
-
-interface BrainHistoryResponse {
-  runs: BrainRun[];
-}
-
-// Helper to format dates
-const formatDate = (timestamp: number): string => {
-  const date = new Date(timestamp);
-  return date.toLocaleDateString() + ' ' + date.toLocaleTimeString();
-};
-
-// Helper to format relative time
-const formatRelativeTime = (timestamp: number): string => {
-  const now = Date.now();
-  const diffMs = now - timestamp;
-  const diffMins = Math.floor(diffMs / (1000 * 60));
-  const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
-  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-
-  if (diffMins < 1) {
-    return 'just now';
-  } else if (diffMins < 60) {
-    return `${diffMins} min ago`;
-  } else if (diffHours < 24) {
-    return `${diffHours} hr ago`;
-  } else {
-    return `${diffDays} day${diffDays === 1 ? '' : 's'} ago`;
-  }
-};
-
-// Helper to format duration
-const formatDuration = (startMs: number, endMs: number): string => {
-  const durationMs = endMs - startMs;
-  const seconds = Math.floor(durationMs / 1000);
-  const minutes = Math.floor(seconds / 60);
-  
-  if (seconds < 60) {
-    return `${seconds}s`;
-  } else {
-    const remainingSeconds = seconds % 60;
-    return `${minutes}m ${remainingSeconds}s`;
-  }
-};
-
-// Helper to get status color
-const getStatusColor = (status: string): string => {
-  switch (status) {
-    case 'COMPLETE':
-      return 'green';
-    case 'ERROR':
-      return 'red';
-    case 'RUNNING':
-      return 'yellow';
-    default:
-      return 'gray';
-  }
-};
-
-// Helper to pad text to column width
-const padRight = (text: string, width: number): string => {
-  return text + ' '.repeat(Math.max(0, width - text.length));
-};
-
-// Helper to truncate text
-const truncate = (text: string, maxWidth: number): string => {
-  if (text.length <= maxWidth) return text;
-  return text.substring(0, maxWidth - 3) + '...';
-};
-
-export const BrainHistory = ({ brainName, limit }: BrainHistoryProps) => {
-  const url = `/brains/${encodeURIComponent(brainName)}/history?limit=${limit}`;
-  const { data, loading, error } = useApiGet<BrainHistoryResponse>(url);
-
-  if (error) {
-    return <ErrorComponent error={error} />;
-  }
-
-  if (loading) {
-    return (
-      <Box>
-        <Text>🧠 Loading brain history...</Text>
-      </Box>
-    );
-  }
-
-  if (!data || data.runs.length === 0) {
-    return (
-      <Box flexDirection="column">
-        <Text>No run history found for brain: {brainName}</Text>
-        <Box marginTop={1}>
-          <Text dimColor>
-            Tip: Run this brain with "px run {brainName}" to create history
-          </Text>
-        </Box>
-      </Box>
-    );
-  }
-
-  // Define column widths
-  const columns = {
-    runId: { header: 'Run ID', width: 38 },
-    status: { header: 'Status', width: 10 },
-    type: { header: 'Type', width: 10 },
-    when: { header: 'When', width: 12 },
-    duration: { header: 'Duration', width: 10 },
-    startedAt: { header: 'Started At', width: 20 },
-  };
-
-  return (
-    <Box flexDirection="column" paddingTop={1} paddingBottom={1}>
-      <Text bold>
-        Recent runs for brain "{brainName}" ({data.runs.length} shown):
-      </Text>
-
-      <Box marginTop={1} flexDirection="column">
-        {/* Header row */}
-        <Box>
-          <Text bold color="cyan">{padRight(columns.runId.header, columns.runId.width)}</Text>
-          <Text>  </Text>
-          <Text bold color="cyan">{padRight(columns.status.header, columns.status.width)}</Text>
-          <Text>  </Text>
-          <Text bold color="cyan">{padRight(columns.type.header, columns.type.width)}</Text>
-          <Text>  </Text>
-          <Text bold color="cyan">{padRight(columns.when.header, columns.when.width)}</Text>
-          <Text>  </Text>
-          <Text bold color="cyan">{padRight(columns.duration.header, columns.duration.width)}</Text>
-          <Text>  </Text>
-          <Text bold color="cyan">{padRight(columns.startedAt.header, columns.startedAt.width)}</Text>
-        </Box>
-
-        {/* Separator */}
-        <Box>
-          <Text dimColor>{'─'.repeat(112)}</Text>
-        </Box>
-
-        {/* Data rows */}
-        {data.runs.map((run) => {
-          const duration = run.startedAt && run.completedAt 
-            ? formatDuration(run.startedAt, run.completedAt)
-            : run.status === 'RUNNING' ? 'Running...' : 'N/A';
-
-          return (
-            <Box key={run.brainRunId}>
-              <Text>{padRight(truncate(run.brainRunId, columns.runId.width), columns.runId.width)}</Text>
-              <Text>  </Text>
-              <Text color={getStatusColor(run.status)}>
-                {padRight(run.status, columns.status.width)}
-              </Text>
-              <Text>  </Text>
-              <Text>{padRight(run.type || 'N/A', columns.type.width)}</Text>
-              <Text>  </Text>
-              <Text dimColor>{padRight(formatRelativeTime(run.createdAt), columns.when.width)}</Text>
-              <Text>  </Text>
-              <Text>{padRight(duration, columns.duration.width)}</Text>
-              <Text>  </Text>
-              <Text dimColor>{padRight(run.startedAt ? formatDate(run.startedAt) : 'N/A', columns.startedAt.width)}</Text>
-            </Box>
-          );
-        })}
-
-        {/* Show errors if any */}
-        {data.runs.filter(r => r.status === 'ERROR' && r.error).length > 0 && (
-          <Box flexDirection="column" marginTop={1}>
-            <Text bold color="red">Errors:</Text>
-            {data.runs.filter(r => r.status === 'ERROR' && r.error).map((run) => (
-              <Box key={run.brainRunId} marginLeft={2}>
-                <Text dimColor>{run.brainRunId}: </Text>
-                <Text color="red">{typeof run.error === 'string' ? run.error : JSON.stringify(run.error)}</Text>
-              </Box>
-            ))}
-          </Box>
-        )}
-      </Box>
-    </Box>
-  );
-};

package/src/components/brain-list.tsx

@@ -1,105 +0,0 @@
-import React from 'react';
-import { Text, Box } from 'ink';
-import { ErrorComponent } from './error.js';
-import { useApiGet } from '../hooks/useApi.js';
-
-interface Brain {
-  name: string;
-  title: string;
-  description: string;
-}
-
-interface BrainsResponse {
-  brains: Brain[];
-  count: number;
-}
-
-// Helper to truncate text to fit column width
-const truncate = (text: string, maxWidth: number): string => {
-  if (text.length <= maxWidth) return text;
-  return text.substring(0, maxWidth - 3) + '...';
-};
-
-// Helper to pad text to column width
-const padRight = (text: string, width: number): string => {
-  return text + ' '.repeat(Math.max(0, width - text.length));
-};
-
-export const BrainList = () => {
-  const { data, loading, error } = useApiGet<BrainsResponse>('/brains');
-
-  if (error) {
-    return <ErrorComponent error={error} />;
-  }
-
-  if (loading) {
-    return (
-      <Box>
-        <Text>🧠 Loading brains...</Text>
-      </Box>
-    );
-  }
-
-  if (!data || data.brains.length === 0) {
-    return (
-      <Box flexDirection="column">
-        <Text>No brains found.</Text>
-        <Box marginTop={1}>
-          <Text dimColor>
-            Tip: Create a brain with "px brain new &lt;name&gt;" or add .ts files to the brains/ directory
-          </Text>
-        </Box>
-      </Box>
-    );
-  }
-
-  // Sort brains alphabetically by name
-  const sortedBrains = [...data.brains].sort((a, b) => a.name.localeCompare(b.name));
-
-  // Define column widths
-  const columns = {
-    name: { header: 'Name', width: 25 },
-    title: { header: 'Title', width: 35 },
-    description: { header: 'Description', width: 50 },
-  };
-
-  // Calculate total width for separator
-  const totalWidth = Object.values(columns).reduce((sum, col) => sum + col.width + 2, 0) - 2;
-
-  return (
-    <Box flexDirection="column" paddingTop={1} paddingBottom={1}>
-      <Text bold>
-        Found {data.count} brain{data.count === 1 ? '' : 's'}:
-      </Text>
-
-      <Box marginTop={1} flexDirection="column">
-        {/* Header row */}
-        <Box>
-          <Text bold color="cyan">{padRight(columns.name.header, columns.name.width)}</Text>
-          <Text>  </Text>
-          <Text bold color="cyan">{padRight(columns.title.header, columns.title.width)}</Text>
-          <Text>  </Text>
-          <Text bold color="cyan">{padRight(columns.description.header, columns.description.width)}</Text>
-        </Box>
-
-        {/* Separator */}
-        <Box>
-          <Text dimColor>{'─'.repeat(totalWidth)}</Text>
-        </Box>
-
-        {/* Data rows */}
-        {sortedBrains.map((brain) => {
-          return (
-            <Box key={brain.name}>
-              <Text>{padRight(truncate(brain.name, columns.name.width), columns.name.width)}</Text>
-              <Text>  </Text>
-              <Text>{padRight(truncate(brain.title, columns.title.width), columns.title.width)}</Text>
-              <Text>  </Text>
-              <Text dimColor>{padRight(truncate(brain.description, columns.description.width), columns.description.width)}</Text>
-            </Box>
-          );
-        })}
-      </Box>
-    </Box>
-  );
-};

package/src/components/brain-rerun.tsx

@@ -1,111 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Text, Box } from 'ink';
-import { apiClient } from '../commands/helpers.js';
-import { ErrorComponent } from './error.js';
-
-interface BrainRerunProps {
-  brainName: string;
-  runId?: string;
-  startsAt?: number;
-  stopsAfter?: number;
-}
-
-interface BrainRerunResponse {
-  brainRunId: string;
-}
-
-export const BrainRerun = ({ brainName, runId, startsAt, stopsAfter }: BrainRerunProps) => {
-  const [isLoading, setIsLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
-  const [newRunId, setNewRunId] = useState<string | null>(null);
-
-  useEffect(() => {
-    const rerunBrain = async () => {
-      try {
-        const body: any = { brainName };
-        if (runId) body.runId = runId;
-        if (startsAt !== undefined) body.startsAt = startsAt;
-        if (stopsAfter !== undefined) body.stopsAfter = stopsAfter;
-
-        const response = await apiClient.fetch('/brains/runs/rerun', {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify(body),
-        });
-
-        if (response.status === 201) {
-          const result = (await response.json()) as BrainRerunResponse;
-          setNewRunId(result.brainRunId);
-        } else if (response.status === 404) {
-          const errorData = await response.json();
-          setError(errorData.error || `Brain or run not found`);
-        } else {
-          const errorText = await response.text();
-          setError(`Server returned ${response.status}: ${errorText}`);
-        }
-      } catch (err: any) {
-        setError(`Connection error: ${err.message}`);
-      } finally {
-        setIsLoading(false);
-      }
-    };
-
-    rerunBrain();
-  }, [brainName, runId, startsAt, stopsAfter]);
-
-  if (isLoading) {
-    return (
-      <Box>
-        <Text>🔄 Starting brain rerun...</Text>
-      </Box>
-    );
-  }
-
-  if (error) {
-    const errorDetails = runId 
-      ? `Make sure the brain "${brainName}" and run ID "${runId}" exist.\nYou can list brain history with: positronic brain history ${brainName}`
-      : `Make sure the brain "${brainName}" exists.\nYou can list available brains with: positronic brain list`;
-
-    return (
-      <ErrorComponent
-        error={{
-          title: 'Brain Rerun Failed',
-          message: error,
-          details: errorDetails
-        }}
-      />
-    );
-  }
-
-  if (newRunId) {
-    const runDetails = runId ? ` from run ${runId}` : '';
-    const rangeDetails = startsAt || stopsAfter
-      ? ` (${startsAt ? `starting at step ${startsAt}` : ''}${startsAt && stopsAfter ? ', ' : ''}${stopsAfter ? `stopping after step ${stopsAfter}` : ''})`
-      : '';
-
-    return (
-      <Box flexDirection="column">
-        <Text bold color="green">✅ Brain rerun started successfully!</Text>
-        <Text>
-          New run ID: <Text bold>{newRunId}</Text>
-        </Text>
-        <Text dimColor>
-          Rerunning brain "{brainName}"{runDetails}{rangeDetails}
-        </Text>
-        <Box marginTop={1}>
-          <Text dimColor>
-            Watch the run with: positronic watch --run-id {newRunId}
-          </Text>
-        </Box>
-      </Box>
-    );
-  }
-
-  return (
-    <Box>
-      <Text color="red">❌ Unexpected error occurred</Text>
-    </Box>
-  );
-};

package/src/components/brain-show.tsx

@@ -1,92 +0,0 @@
-import React from 'react';
-import { Text, Box } from 'ink';
-import { useApiGet } from '../hooks/useApi.js';
-import { ErrorComponent } from './error.js';
-
-interface BrainStep {
-  type: 'step' | 'brain';
-  title: string;
-  innerBrain?: {
-    title: string;
-    description?: string;
-    steps: BrainStep[];
-  };
-}
-
-interface BrainDetails {
-  name: string;
-  title: string;
-  description?: string;
-  steps: BrainStep[];
-}
-
-interface BrainShowProps {
-  brainName: string;
-}
-
-const StepDisplay: React.FC<{ step: BrainStep; indent?: number }> = ({ step, indent = 0 }) => {
-  const indentStr = '  '.repeat(indent);
-  
-  if (step.type === 'step') {
-    return (
-      <Text>
-        {indentStr}• {step.title}
-      </Text>
-    );
-  } else {
-    // Nested brain
-    return (
-      <Box flexDirection="column">
-        <Text>
-          {indentStr}▸ {step.title} <Text dimColor>(nested brain)</Text>
-        </Text>
-        {step.innerBrain?.steps.map((innerStep, idx) => (
-          <StepDisplay key={idx} step={innerStep} indent={indent + 1} />
-        ))}
-      </Box>
-    );
-  }
-};
-
-export const BrainShow = ({ brainName }: BrainShowProps) => {
-  const { data, loading, error } = useApiGet<BrainDetails>(`/brains/${encodeURIComponent(brainName)}`);
-
-  if (loading) {
-    return (
-      <Box>
-        <Text>🧠 Loading brain details...</Text>
-      </Box>
-    );
-  }
-
-  if (error) {
-    return <ErrorComponent error={error} />;
-  }
-
-  if (!data) {
-    return (
-      <Box flexDirection="column">
-        <Text color="red">Brain '{brainName}' not found</Text>
-      </Box>
-    );
-  }
-
-  return (
-    <Box flexDirection="column" gap={1}>
-      <Text bold underline>{data.title}</Text>
-      
-      {data.description && (
-        <Text dimColor>{data.description}</Text>
-      )}
-      
-      <Box flexDirection="column">
-        <Text bold>Steps:</Text>
-        <Box flexDirection="column" marginLeft={1}>
-          {data.steps.map((step: BrainStep, idx: number) => (
-            <StepDisplay key={idx} step={step} />
-          ))}
-        </Box>
-      </Box>
-    </Box>
-  );
-};

package/src/components/error.tsx

@@ -1,24 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-
-interface ErrorComponentProps {
-  error: {
-    title: string;
-    message: string;
-    details?: string;
-  };
-}
-
-export const ErrorComponent = ({ error }: ErrorComponentProps) => {
-  return (
-    <Box flexDirection="column">
-      <Text color="red" bold>❌ {error.title}</Text>
-      <Box paddingLeft={2} flexDirection="column">
-        <Text color="red">{error.message}</Text>
-        {error.details && (
-          <Text color="red" dimColor>{error.details}</Text>
-        )}
-      </Box>
-    </Box>
-  );
-};

package/src/components/project-add.tsx

@@ -1,59 +0,0 @@
-import React, { useEffect, useState } from 'react';
-import { Box, Text } from 'ink';
-import type { ProjectConfigManager } from '../commands/project-config-manager.js';
-
-interface ProjectAddProps {
-  name: string;
-  url: string;
-  projectConfig: ProjectConfigManager;
-}
-
-export const ProjectAdd = ({ name, url, projectConfig }: ProjectAddProps) => {
-  const [result, setResult] = useState<{ success: boolean; error?: string } | null>(null);
-
-  useEffect(() => {
-    const addResult = projectConfig.addProject(name, url);
-    setResult(addResult);
-  }, [name, url, projectConfig]);
-
-  if (!result) {
-    return <Text>Adding project...</Text>;
-  }
-
-  if (result.success) {
-    const config = projectConfig.read();
-    const isCurrentProject = config.currentProject === name;
-
-    return (
-      <Box flexDirection="column">
-        <Text color="green">✅ Project "{name}" added successfully!</Text>
-        <Box marginTop={1} paddingLeft={2} flexDirection="column">
-          <Text>
-            <Text bold>URL:</Text> {url}
-          </Text>
-          {isCurrentProject && (
-            <Text>
-              <Text bold>Status:</Text> <Text color="cyan">Current project</Text>
-            </Text>
-          )}
-        </Box>
-        <Box marginTop={1}>
-          <Text dimColor>
-            {isCurrentProject
-              ? 'This project is now your active project.'
-              : `Use "px project select ${name}" to switch to this project.`}
-          </Text>
-        </Box>
-      </Box>
-    );
-  }
-
-  return (
-    <Box flexDirection="column">
-      <Text color="red">❌ Failed to add project</Text>
-      <Box paddingLeft={2}>
-        <Text color="red">{result.error}</Text>
-      </Box>
-    </Box>
-  );
-};

package/src/components/project-create.tsx

@@ -1,83 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Box, Text } from 'ink';
-import { generateProject } from '../commands/helpers.js';
-import path from 'path';
-
-interface ProjectCreateProps {
-  projectPathArg: string;
-}
-
-export const ProjectCreate = ({ projectPathArg }: ProjectCreateProps) => {
-  const [status, setStatus] = useState<'creating' | 'success' | 'error'>('creating');
-  const [error, setError] = useState<string | null>(null);
-  const [projectDir, setProjectDir] = useState<string>('');
-  const [projectName, setProjectName] = useState<string>('');
-
-  useEffect(() => {
-    const createProject = async () => {
-      try {
-        const resolvedProjectDir = path.resolve(projectPathArg);
-        const resolvedProjectName = path.basename(resolvedProjectDir);
-
-        setProjectDir(resolvedProjectDir);
-        setProjectName(resolvedProjectName);
-
-        await generateProject(resolvedProjectName, resolvedProjectDir);
-        setStatus('success');
-      } catch (err) {
-        setError(err instanceof Error ? err.message : 'Unknown error occurred');
-        setStatus('error');
-      }
-    };
-
-    createProject();
-  }, [projectPathArg]);
-
-  if (status === 'creating') {
-    return (
-      <Box flexDirection="column">
-        <Text>Creating project...</Text>
-      </Box>
-    );
-  }
-
-  if (status === 'error') {
-    return (
-      <Box flexDirection="column">
-        <Text color="red">Error creating project: {error}</Text>
-      </Box>
-    );
-  }
-
-  return (
-    <Box flexDirection="column" paddingTop={1} paddingBottom={1}>
-      <Text bold color="green">Project Created Successfully!</Text>
-      <Box marginTop={1} paddingLeft={2} flexDirection="column">
-        <Text>
-          <Text bold>Name:</Text> {projectName}
-        </Text>
-        <Text>
-          <Text bold>Location:</Text> {projectDir}
-        </Text>
-      </Box>
-
-      <Box marginTop={1} flexDirection="column">
-        <Text bold>Next steps:</Text>
-        <Box paddingLeft={2} flexDirection="column">
-          <Text>
-            <Text bold>1.</Text> cd {projectDir}
-          </Text>
-          <Text>
-            <Text bold>2.</Text> Install dependencies if you didn't choose to during setup (e.g., npm install)
-          </Text>
-          <Text>
-            <Text bold>3.</Text> Run the development server: px s or positronic server
-          </Text>
-          <Text>
-            <Text bold>4.</Text> Open a new terminal in '{projectName}' and run a brain: px run example --watch
-          </Text>
-        </Box>
-      </Box>
-    </Box>
-  );
-};