thatgfsj-code 0.6.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

@@ -1,10 +1,11 @@
 /** @jsxImportSource react */
-import React, { useState, useCallback, useEffect } from 'react';
-import { Box, Text, useApp, useStdout } from 'ink';
+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';
@@ -19,10 +20,10 @@ export function TuiApp({ app }: Props) {
   const { messages, isThinking, streaming, streamingToolCalls, sendMessage } = useChat(app);
   const { handleCommand } = useCommands(app);
   const [systemMessages, setSystemMessages] = useState<MessageData[]>([]);
-  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const terminalWidth = stdout?.columns || 80;
 
   const onSubmit = useCallback(async (input: string) => {
-    // Check for built-in commands first
     const result = handleCommand(input);
     if (result.handled) {
       if (result.output) {
@@ -32,29 +33,29 @@ export function TuiApp({ app }: Props) {
           { role: 'assistant', content: result.output! },
         ]);
       }
-      // Handle clear
       if (input.toLowerCase().trim() === 'clear') {
         setSystemMessages([]);
       }
       return;
     }
-
-    // Send to AI
     await sendMessage(input);
   }, [handleCommand, sendMessage]);
 
   const allMessages = [...systemMessages, ...messages];
+  const activeSkills = app.skills.listActive().map(s => s.id);
 
   return (
-    <Box flexDirection="column" padding={1}>
+    <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

@@ -2,18 +2,20 @@
 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?: Array<{ name: string; args: string }>;
+  streamingToolCalls?: ToolCallData[];
+  width?: number;
 }
 
-export function ChatList({ messages, streaming, streamingToolCalls }: Props) {
+export function ChatList({ messages, streaming, streamingToolCalls, width }: Props) {
   return (
     <Box flexDirection="column" flexGrow={1}>
       {messages.map((msg, i) => (
-        <ChatMessage key={i} message={msg} />
+        <ChatMessage key={i} message={msg} width={width} />
       ))}
       {(streaming || streamingToolCalls) && (
         <ChatMessage
@@ -22,6 +24,7 @@ export function ChatList({ messages, streaming, streamingToolCalls }: Props) {
             content: streaming || '',
             toolCalls: streamingToolCalls,
           }}
+          width={width}
         />
       )}
     </Box>

package/src/tui/components/ChatMessage.tsx

@@ -12,40 +12,43 @@ interface MessageData {
 
 interface Props {
   message: MessageData;
+  width?: number;
 }
 
-function UserMessage({ content }: { content: string }) {
+function UserMessage({ content, width }: { content: string; width?: number }) {
   return (
-    <Box flexDirection="column" marginBottom={1}>
-      <Text bold>You</Text>
-      <Box paddingLeft={2}>
+    <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 }: { content: string; toolCalls?: ToolCallData[] }) {
+function AssistantMessage({ content, toolCalls, width }: { content: string; toolCalls?: ToolCallData[]; width?: number }) {
   return (
     <Box flexDirection="column" marginBottom={1}>
-      <Text bold color="cyan">AI</Text>
       {toolCalls && toolCalls.map((tc, i) => (
-        <ToolCall key={i} tool={tc} />
+        <ToolCall key={i} tool={tc} width={width} />
       ))}
       {content && (
-        <Box paddingLeft={2} flexDirection="column">
-          <Markdown content={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 }: Props) {
+export function ChatMessage({ message, width }: Props) {
   if (message.role === 'user') {
-    return <UserMessage content={message.content} />;
+    return <UserMessage content={message.content} width={width} />;
   }
-  return <AssistantMessage content={message.content} toolCalls={message.toolCalls} />;
+  return <AssistantMessage content={message.content} toolCalls={message.toolCalls} width={width} />;
 }
 
 export type { MessageData };

package/src/tui/components/Header.tsx

@@ -9,14 +9,20 @@ interface Props {
 
 export function Header({ provider, model }: Props) {
   return (
-    <Box flexDirection="column" marginBottom={1}>
-      <Box>
-        <Text bold color="cyan"> ⚡ Thatgfsj Code </Text>
-        <Text dimColor> v0.6.0</Text>
-        <Text dimColor> │ </Text>
-        <Text dimColor>{provider} / {model}</Text>
+    <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 dimColor>{'─'.repeat(60)}</Text>
+      <Text color="#374151">{'─'.repeat(80)}</Text>
     </Box>
   );
 }

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

@@ -9,11 +9,11 @@ interface Props {
 
 export function Thinking({ message = 'Thinking' }: Props) {
   return (
-    <Box>
-      <Text color="cyan">
+    <Box paddingLeft={1}>
+      <Text color="#06B6D4">
         <Spinner type="dots" />
       </Text>
-      <Text dimColor> {message}</Text>
+      <Text color="#06B6D4"> {message}</Text>
     </Box>
   );
 }

package/src/tui/components/ToolCall.tsx

@@ -11,58 +11,60 @@ interface ToolCallData {
 
 interface Props {
   tool: ToolCallData;
+  width?: number;
 }
 
-function formatArgs(args: string): string {
+function formatToolParams(name: string, args: string): string {
   try {
     const obj = JSON.parse(args);
-    const entries = Object.entries(obj);
-    if (entries.length === 0) return '';
-    return entries
-      .map(([k, v]) => {
-        const val = typeof v === 'string' && v.length > 60
-          ? v.slice(0, 60) + '...'
-          : JSON.stringify(v);
-        return `${k}=${val}`;
-      })
-      .join(' ');
+    switch (name) {
+      case 'file': {
+        const action = obj.action || '';
+        const path = (obj.path || '').replace(/.*[/\\]/, '');
+        return `${action} ${path || obj.path || ''}`;
+      }
+      case 'shell': return obj.command || '';
+      case 'git': return obj.command || '';
+      case 'search': return obj.query || obj.pattern || '';
+      case 'nwt': return obj.action || '';
+      default: {
+        const first = Object.entries(obj)[0];
+        if (!first) return '';
+        const val = typeof first[1] === 'string' && first[1].length > 40
+          ? first[1].slice(0, 40) + '...'
+          : JSON.stringify(first[1]);
+        return `${first[0]}=${val}`;
+      }
+    }
   } catch {
-    return args.length > 80 ? args.slice(0, 80) + '...' : args;
+    return args.length > 50 ? args.slice(0, 50) + '...' : args;
   }
 }
 
-function formatResult(output: string, maxLines = 15): { text: string; truncated: boolean } {
+function formatResult(output: string, maxLines = 10): { text: string; truncated: boolean } {
   const lines = output.split('\n');
-  if (lines.length <= maxLines) {
-    return { text: output, truncated: false };
-  }
-  return {
-    text: lines.slice(0, maxLines).join('\n'),
-    truncated: true,
-  };
+  if (lines.length <= maxLines) return { text: output, truncated: false };
+  return { text: lines.slice(0, maxLines).join('\n'), truncated: true };
 }
 
-export function ToolCall({ tool }: Props) {
-  const argsStr = formatArgs(tool.args);
+export function ToolCall({ tool, width }: Props) {
+  const params = formatToolParams(tool.name, tool.args);
   const result = tool.result ? formatResult(tool.result) : null;
 
   return (
-    <Box flexDirection="column" marginY={0}>
+    <Box borderStyle="round" borderLeft borderColor="#06B6D4" paddingLeft={1} flexDirection="column" marginBottom={0}>
       <Box>
-        <Text color="yellow"> ⚙ </Text>
-        <Text bold color="yellow">{tool.name}</Text>
-        {argsStr && <Text dimColor> {argsStr}</Text>}
+        <Text color="#06B6D4" bold>⚙ {tool.name}: </Text>
+        <Text color="#94A3B8">{params}</Text>
       </Box>
       {result && (
-        <Box paddingLeft={4} flexDirection="column">
+        <Box paddingLeft={1} flexDirection="column">
           {result.text.split('\n').map((line, i) => (
-            <Text key={i} dimColor={tool.isError} color={tool.isError ? 'red' : undefined}>
-              {tool.isError ? '✖ ' : '│ '}{line}
+            <Text key={i} color={tool.isError ? '#EF4444' : '#64748B'}>
+              {line}
             </Text>
           ))}
-          {result.truncated && (
-            <Text dimColor>│ ... (truncated)</Text>
-          )}
+          {result.truncated && <Text dimColor>...</Text>}
         </Box>
       )}
     </Box>