thatgfsj-code 0.5.0 → 0.7.0

package/src/tools/nwt.ts

@@ -0,0 +1,362 @@
+/**
+ * NeuroWeave Timeline (NWT) Tool - Project evolution memory
+ * Built-in port of https://github.com/Thatgfsj/neuroweave-timeline
+ *
+ * Stores meaningful actions (decisions, refactors, bug fixes) as timeline events
+ * in .nwt/ directory. Supports monthly archives (max 1 month per archive).
+ */
+
+import type { Tool, ToolResult } from './types.js';
+import {
+  readFileSync, writeFileSync, existsSync, mkdirSync,
+  readdirSync, renameSync
+} from 'fs';
+import { join } from 'path';
+
+interface TimelineEvent {
+  id: string;
+  timestamp: string;
+  task: string;
+  summary: string;
+  reason?: string;
+  files: string[];
+  tags: string[];
+  parent?: string;
+}
+
+const NWT_DIR = '.nwt';
+const EVENTS_DIR = 'events';
+const ARCHIVE_DIR = 'archives';
+const MAX_EVENTS = 500;
+const ARCHIVE_AFTER_DAYS = 30;
+
+export class NwtTool implements Tool {
+  name = 'nwt';
+  description = 'NeuroWeave Timeline - Project evolution memory. Log decisions, track changes, search history. Actions: init, log, history, search, story, explain, archive';
+
+  inputSchema = {
+    type: 'object' as const,
+    properties: {
+      action: {
+        type: 'string',
+        description: 'Action: init, log, history, search, story, explain, archive',
+      },
+      task: { type: 'string', description: 'Short imperative title (for log)' },
+      summary: { type: 'string', description: 'What was done (for log)' },
+      reason: { type: 'string', description: 'Why it was done (for log)' },
+      files: { type: 'string', description: 'Comma-separated file paths (for log)' },
+      tags: { type: 'string', description: 'Comma-separated tags (for log)' },
+      query: { type: 'string', description: 'Search query (for search/explain)' },
+      limit: { type: 'number', description: 'Max results (for history/search)' },
+    },
+    required: ['action'],
+  };
+
+  metadata = {
+    permissions: ['read', 'write'] as ('read' | 'write' | 'execute' | 'network')[],
+    tags: ['nwt', 'timeline', 'memory', 'history'],
+  };
+
+  parameters = [
+    { name: 'action', type: 'string', description: 'Action to perform', required: true },
+    { name: 'task', type: 'string', description: 'Short title', required: false },
+    { name: 'summary', type: 'string', description: 'What was done', required: false },
+    { name: 'reason', type: 'string', description: 'Why it was done', required: false },
+    { name: 'files', type: 'string', description: 'Comma-separated file paths', required: false },
+    { name: 'tags', type: 'string', description: 'Comma-separated tags', required: false },
+    { name: 'query', type: 'string', description: 'Search query', required: false },
+    { name: 'limit', type: 'number', description: 'Max results', required: false },
+  ];
+
+  async execute(params: Record<string, any>, ctx?: any): Promise<ToolResult> {
+    const cwd = ctx?.workingDirectory || process.cwd();
+    const action = params.action;
+
+    try {
+      switch (action) {
+        case 'init':
+          return this.init(cwd);
+        case 'log':
+          return this.log(cwd, params);
+        case 'history':
+          return this.history(cwd, params.limit || 20);
+        case 'search':
+          return this.search(cwd, params.query || '', params.limit || 20);
+        case 'story':
+          return this.story(cwd);
+        case 'explain':
+          return this.explain(cwd, params.query || '');
+        case 'archive':
+          return this.archive(cwd);
+        default:
+          return { success: false, error: `Unknown action: ${action}` };
+      }
+    } catch (error: any) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  // ── Init ──────────────────────────────────────────────
+
+  private init(cwd: string): ToolResult {
+    const nwtDir = join(cwd, NWT_DIR);
+    const eventsDir = join(nwtDir, EVENTS_DIR);
+    const archiveDir = join(nwtDir, ARCHIVE_DIR);
+
+    if (!existsSync(nwtDir)) mkdirSync(nwtDir, { recursive: true });
+    if (!existsSync(eventsDir)) mkdirSync(eventsDir, { recursive: true });
+    if (!existsSync(archiveDir)) mkdirSync(archiveDir, { recursive: true });
+
+    // Write metadata
+    const meta = {
+      version: '1.0.0',
+      created: new Date().toISOString(),
+      description: 'NeuroWeave Timeline - Project evolution memory',
+    };
+    writeFileSync(join(nwtDir, 'meta.json'), JSON.stringify(meta, null, 2));
+
+    return { success: true, output: 'NWT initialized in .nwt/' };
+  }
+
+  // ── Log Event ─────────────────────────────────────────
+
+  private log(cwd: string, params: Record<string, any>): ToolResult {
+    const nwtDir = join(cwd, NWT_DIR);
+    if (!existsSync(nwtDir)) {
+      this.init(cwd);
+    }
+
+    const { task, summary, reason, files, tags } = params;
+    if (!task || !summary) {
+      return { success: false, error: 'task and summary are required' };
+    }
+
+    // Get next ID
+    const eventsDir = join(nwtDir, EVENTS_DIR);
+    const existing = existsSync(eventsDir)
+      ? readdirSync(eventsDir).filter(f => f.endsWith('.json'))
+      : [];
+    const nextId = (existing.length + 1).toString().padStart(6, '0');
+
+    // Get parent (last event)
+    const parent = existing.length > 0
+      ? existing.sort().pop()?.replace('.json', '')
+      : undefined;
+
+    const event: TimelineEvent = {
+      id: nextId,
+      timestamp: new Date().toISOString(),
+      task: task.trim(),
+      summary: summary.trim(),
+      reason: reason?.trim() || undefined,
+      files: files ? files.split(',').map((f: string) => f.trim()).filter(Boolean) : [],
+      tags: tags ? tags.split(',').map((t: string) => t.trim().toLowerCase()).filter(Boolean) : [],
+      parent: parent || undefined,
+    };
+
+    writeFileSync(
+      join(eventsDir, `${nextId}.json`),
+      JSON.stringify(event, null, 2)
+    );
+
+    // Auto-archive if too many events
+    if (existing.length >= MAX_EVENTS) {
+      this.archive(cwd);
+    }
+
+    return {
+      success: true,
+      output: `Event [${nextId}] logged: ${event.task}`,
+    };
+  }
+
+  // ── History ───────────────────────────────────────────
+
+  private history(cwd: string, limit: number): ToolResult {
+    const events = this.loadEvents(cwd);
+    if (events.length === 0) {
+      return { success: true, output: 'No events yet. Use nwt log to start tracking.' };
+    }
+
+    const recent = events.slice(-limit);
+    const lines = recent.map(e => {
+      const time = e.timestamp.split('T')[0];
+      const files = e.files.length > 0 ? ` [${e.files.join(', ')}]` : '';
+      const tags = e.tags.length > 0 ? ` {${e.tags.join(', ')}}` : '';
+      return `[${e.id}] ${time} ${e.task}${files}${tags}`;
+    });
+
+    return { success: true, output: lines.join('\n') };
+  }
+
+  // ── Search ────────────────────────────────────────────
+
+  private search(cwd: string, query: string, limit: number): ToolResult {
+    if (!query) return { success: false, error: 'query is required' };
+
+    const events = this.loadEvents(cwd);
+    const q = query.toLowerCase();
+    const matches = events.filter(e =>
+      e.task.toLowerCase().includes(q) ||
+      e.summary.toLowerCase().includes(q) ||
+      (e.reason || '').toLowerCase().includes(q) ||
+      e.files.some(f => f.toLowerCase().includes(q)) ||
+      e.tags.some(t => t.includes(q))
+    ).slice(-limit);
+
+    if (matches.length === 0) {
+      return { success: true, output: `No events matching "${query}"` };
+    }
+
+    const lines = matches.map(e => {
+      const time = e.timestamp.split('T')[0];
+      return `[${e.id}] ${time} ${e.task}\n    ${e.summary}`;
+    });
+
+    return { success: true, output: lines.join('\n\n') };
+  }
+
+  // ── Story ─────────────────────────────────────────────
+
+  private story(cwd: string): ToolResult {
+    const events = this.loadEvents(cwd);
+    if (events.length === 0) {
+      return { success: true, output: 'No events yet.' };
+    }
+
+    // Group by tags and find milestones
+    const milestones = events.filter(e => e.tags.includes('milestone'));
+    const decisions = events.filter(e => e.tags.includes('decision'));
+    const totalFiles = new Set(events.flatMap(e => e.files)).size;
+
+    const lines = [
+      `Project Story: ${events.length} events, ${totalFiles} files touched`,
+      '',
+    ];
+
+    if (milestones.length > 0) {
+      lines.push('Milestones:');
+      for (const m of milestones.slice(-5)) {
+        lines.push(`  [${m.id}] ${m.task} - ${m.summary}`);
+      }
+      lines.push('');
+    }
+
+    if (decisions.length > 0) {
+      lines.push('Key Decisions:');
+      for (const d of decisions.slice(-5)) {
+        lines.push(`  [${d.id}] ${d.task}${d.reason ? ` - ${d.reason}` : ''}`);
+      }
+      lines.push('');
+    }
+
+    lines.push('Recent Activity:');
+    for (const e of events.slice(-5)) {
+      const time = e.timestamp.split('T')[0];
+      lines.push(`  ${time} ${e.task}`);
+    }
+
+    return { success: true, output: lines.join('\n') };
+  }
+
+  // ── Explain File ──────────────────────────────────────
+
+  private explain(cwd: string, filePath: string): ToolResult {
+    if (!filePath) return { success: false, error: 'file path is required' };
+
+    const events = this.loadEvents(cwd);
+    const matches = events.filter(e =>
+      e.files.some(f => f === filePath || f.endsWith(filePath))
+    );
+
+    if (matches.length === 0) {
+      return { success: true, output: `No history for "${filePath}"` };
+    }
+
+    const lines = matches.map(e => {
+      const time = e.timestamp.split('T')[0];
+      return `[${e.id}] ${time} ${e.task}\n    ${e.summary}${e.reason ? `\n    Reason: ${e.reason}` : ''}`;
+    });
+
+    return { success: true, output: `History of ${filePath}:\n\n${lines.join('\n\n')}` };
+  }
+
+  // ── Archive ───────────────────────────────────────────
+
+  private archive(cwd: string): ToolResult {
+    const nwtDir = join(cwd, NWT_DIR);
+    const eventsDir = join(nwtDir, EVENTS_DIR);
+    const archiveDir = join(nwtDir, ARCHIVE_DIR);
+
+    if (!existsSync(eventsDir)) {
+      return { success: true, output: 'No events to archive.' };
+    }
+
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - ARCHIVE_AFTER_DAYS);
+
+    const files = readdirSync(eventsDir).filter(f => f.endsWith('.json')).sort();
+    const toArchive: string[] = [];
+    const toKeep: string[] = [];
+
+    for (const file of files) {
+      try {
+        const event = JSON.parse(readFileSync(join(eventsDir, file), 'utf-8'));
+        const eventDate = new Date(event.timestamp);
+        if (eventDate < cutoff) {
+          toArchive.push(file);
+        } else {
+          toKeep.push(file);
+        }
+      } catch {
+        toKeep.push(file);
+      }
+    }
+
+    if (toArchive.length === 0) {
+      return { success: true, output: 'No events old enough to archive.' };
+    }
+
+    // Create archive file
+    const archiveName = `archive-${new Date().toISOString().split('T')[0]}.json`;
+    const archiveEvents = toArchive.map(f => {
+      return JSON.parse(readFileSync(join(eventsDir, f), 'utf-8'));
+    });
+
+    writeFileSync(
+      join(archiveDir, archiveName),
+      JSON.stringify(archiveEvents, null, 2)
+    );
+
+    // Remove archived events from events dir
+    for (const file of toArchive) {
+      const src = join(eventsDir, file);
+      try { renameSync(src, join(archiveDir, file)); } catch {}
+    }
+
+    return {
+      success: true,
+      output: `Archived ${toArchive.length} events to archives/${archiveName}. ${toKeep.length} events remain.`,
+    };
+  }
+
+  // ── Helpers ───────────────────────────────────────────
+
+  private loadEvents(cwd: string): TimelineEvent[] {
+    const eventsDir = join(cwd, NWT_DIR, EVENTS_DIR);
+    if (!existsSync(eventsDir)) return [];
+
+    const files = readdirSync(eventsDir).filter(f => f.endsWith('.json')).sort();
+    const events: TimelineEvent[] = [];
+
+    for (const file of files) {
+      try {
+        events.push(JSON.parse(readFileSync(join(eventsDir, file), 'utf-8')));
+      } catch {
+        // Skip corrupted files
+      }
+    }
+
+    return events;
+  }
+}

package/src/tui/app.tsx

@@ -0,0 +1,61 @@
+/** @jsxImportSource react */
+import React, { useState, useCallback } from 'react';
+import { Box, Text, useStdout } from 'ink';
+import { Header } from './components/Header.js';
+import { ChatList } from './components/ChatList.js';
+import { Thinking } from './components/Thinking.js';
+import { UserInput } from './components/UserInput.js';
+import { StatusBar } from './components/StatusBar.js';
+import { useChat } from './hooks/useChat.js';
+import { useCommands } from './hooks/useCommands.js';
+import type { App } from '../app/index.js';
+import type { MessageData } from './components/ChatMessage.js';
+
+interface Props {
+  app: App;
+}
+
+export function TuiApp({ app }: Props) {
+  const config = app.config.get();
+  const { messages, isThinking, streaming, streamingToolCalls, sendMessage } = useChat(app);
+  const { handleCommand } = useCommands(app);
+  const [systemMessages, setSystemMessages] = useState<MessageData[]>([]);
+  const { stdout } = useStdout();
+  const terminalWidth = stdout?.columns || 80;
+
+  const onSubmit = useCallback(async (input: string) => {
+    const result = handleCommand(input);
+    if (result.handled) {
+      if (result.output) {
+        setSystemMessages(prev => [
+          ...prev,
+          { role: 'user', content: input },
+          { role: 'assistant', content: result.output! },
+        ]);
+      }
+      if (input.toLowerCase().trim() === 'clear') {
+        setSystemMessages([]);
+      }
+      return;
+    }
+    await sendMessage(input);
+  }, [handleCommand, sendMessage]);
+
+  const allMessages = [...systemMessages, ...messages];
+  const activeSkills = app.skills.listActive().map(s => s.id);
+
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      <Header provider={config.provider} model={config.model} />
+      <ChatList
+        messages={allMessages}
+        streaming={streaming}
+        streamingToolCalls={streamingToolCalls}
+        width={terminalWidth - 4}
+      />
+      {isThinking && <Thinking />}
+      <UserInput onSubmit={onSubmit} disabled={isThinking} />
+      <StatusBar messageCount={allMessages.length} skills={activeSkills} />
+    </Box>
+  );
+}

package/src/tui/components/ChatList.tsx

@@ -0,0 +1,32 @@
+/** @jsxImportSource react */
+import React from 'react';
+import { Box } from 'ink';
+import { ChatMessage, type MessageData } from './ChatMessage.js';
+import type { ToolCallData } from './ToolCall.js';
+
+interface Props {
+  messages: MessageData[];
+  streaming?: string;
+  streamingToolCalls?: ToolCallData[];
+  width?: number;
+}
+
+export function ChatList({ messages, streaming, streamingToolCalls, width }: Props) {
+  return (
+    <Box flexDirection="column" flexGrow={1}>
+      {messages.map((msg, i) => (
+        <ChatMessage key={i} message={msg} width={width} />
+      ))}
+      {(streaming || streamingToolCalls) && (
+        <ChatMessage
+          message={{
+            role: 'assistant',
+            content: streaming || '',
+            toolCalls: streamingToolCalls,
+          }}
+          width={width}
+        />
+      )}
+    </Box>
+  );
+}

package/src/tui/components/ChatMessage.tsx

@@ -0,0 +1,54 @@
+/** @jsxImportSource react */
+import React from 'react';
+import { Box, Text } from 'ink';
+import { Markdown } from './Markdown.js';
+import { ToolCall, type ToolCallData } from './ToolCall.js';
+
+interface MessageData {
+  role: 'user' | 'assistant' | 'tool';
+  content: string;
+  toolCalls?: ToolCallData[];
+}
+
+interface Props {
+  message: MessageData;
+  width?: number;
+}
+
+function UserMessage({ content, width }: { content: string; width?: number }) {
+  return (
+    <Box borderStyle="round" borderLeft borderColor="#06B6D4" paddingLeft={1} marginBottom={1}>
+      <Box flexDirection="column" width={width ? width - 4 : undefined}>
+        <Text bold color="#06B6D4">You</Text>
+        <Text>{content}</Text>
+      </Box>
+    </Box>
+  );
+}
+
+function AssistantMessage({ content, toolCalls, width }: { content: string; toolCalls?: ToolCallData[]; width?: number }) {
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      {toolCalls && toolCalls.map((tc, i) => (
+        <ToolCall key={i} tool={tc} width={width} />
+      ))}
+      {content && (
+        <Box borderStyle="round" borderLeft borderColor="#22D3EE" paddingLeft={1}>
+          <Box flexDirection="column" width={width ? width - 4 : undefined}>
+            <Text bold color="#22D3EE">AI</Text>
+            <Markdown content={content} />
+          </Box>
+        </Box>
+      )}
+    </Box>
+  );
+}
+
+export function ChatMessage({ message, width }: Props) {
+  if (message.role === 'user') {
+    return <UserMessage content={message.content} width={width} />;
+  }
+  return <AssistantMessage content={message.content} toolCalls={message.toolCalls} width={width} />;
+}
+
+export type { MessageData };

package/src/tui/components/Header.tsx

@@ -0,0 +1,28 @@
+/** @jsxImportSource react */
+import React from 'react';
+import { Box, Text } from 'ink';
+
+interface Props {
+  provider: string;
+  model: string;
+}
+
+export function Header({ provider, model }: Props) {
+  return (
+    <Box flexDirection="column" marginBottom={0}>
+      <Box justifyContent="space-between" width="100%">
+        <Box>
+          <Text color="#06B6D4" bold> ⚡ </Text>
+          <Text color="#22D3EE" bold>THATGFSJ CODE</Text>
+          <Text dimColor> v0.7.0</Text>
+        </Box>
+        <Box>
+          <Text color="#06B6D4" bold> {provider} </Text>
+          <Text dimColor>/</Text>
+          <Text color="#22D3EE"> {model} </Text>
+        </Box>
+      </Box>
+      <Text color="#374151">{'─'.repeat(80)}</Text>
+    </Box>
+  );
+}

package/src/tui/components/Markdown.tsx

@@ -0,0 +1,35 @@
+/** @jsxImportSource react */
+import React, { useMemo } from 'react';
+import { Text } from 'ink';
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
+
+// Configure marked to use terminal renderer
+marked.setOptions({
+  // @ts-ignore - marked-terminal types are incomplete
+  renderer: new TerminalRenderer({
+    showSectionPrefix: false,
+    tab: 2,
+  }),
+});
+
+interface Props {
+  content: string;
+}
+
+export function Markdown({ content }: Props) {
+  const rendered = useMemo(() => {
+    try {
+      const result = marked.parse(content);
+      // marked.parse returns string | Promise<string> depending on async option
+      if (typeof result === 'string') {
+        return result.trimEnd();
+      }
+      return content;
+    } catch {
+      return content;
+    }
+  }, [content]);
+
+  return <Text>{rendered}</Text>;
+}

package/src/tui/components/StatusBar.tsx

@@ -0,0 +1,30 @@
+/** @jsxImportSource react */
+import React from 'react';
+import { Box, Text } from 'ink';
+
+interface Props {
+  messageCount: number;
+  skills: string[];
+}
+
+export function StatusBar({ messageCount, skills }: Props) {
+  const activeSkills = skills.slice(0, 3).join(', ');
+  const moreSkills = skills.length > 3 ? ` +${skills.length - 3}` : '';
+
+  return (
+    <Box flexDirection="column" marginTop={0}>
+      <Text color="#374151">{'─'.repeat(80)}</Text>
+      <Box justifyContent="space-between" width="100%">
+        <Box>
+          <Text backgroundColor="#06B6D4" color="#0F172A" bold> ⚡ THATGFSJ CODE </Text>
+          <Text dimColor> │ {messageCount} messages</Text>
+        </Box>
+        <Box>
+          {skills.length > 0 && (
+            <Text dimColor> skills: {activeSkills}{moreSkills} </Text>
+          )}
+        </Box>
+      </Box>
+    </Box>
+  );
+}

package/src/tui/components/Thinking.tsx

@@ -0,0 +1,19 @@
+/** @jsxImportSource react */
+import React from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+
+interface Props {
+  message?: string;
+}
+
+export function Thinking({ message = 'Thinking' }: Props) {
+  return (
+    <Box paddingLeft={1}>
+      <Text color="#06B6D4">
+        <Spinner type="dots" />
+      </Text>
+      <Text color="#06B6D4"> {message}</Text>
+    </Box>
+  );
+}