@ramarivera/coding-buddy 0.4.0-alpha.9 → 0.6.0

package/server/mcp-launcher.sh

@@ -1,16 +1,26 @@
 #!/usr/bin/env bash
+# coding-buddy MCP server launcher — preflight checks bun, then execs the server.
+# Failing here with a clear stderr message is much easier to debug than a silent
+# "MCP tools not available" from Claude Code.
+
 set -eu
+
 if ! command -v bun >/dev/null 2>&1; then
-  cat >&2 <<'MSG'
-[claude-buddy] ERROR: 'bun' was not found on PATH.
+  cat >&2 <<'EOF'
+[coding-buddy] ERROR: 'bun' was not found on PATH.
 
-claude-buddy's MCP server runs on bun. Install it with:
+coding-buddy's MCP server runs on bun. Install it with:
 
+  Linux / macOS:
     curl -fsSL https://bun.sh/install | bash
 
-Then open a new shell and restart Claude Code.
-MSG
+  Windows (PowerShell):
+    powershell -c "irm bun.sh/install.ps1 | iex"
+
+Then open a new shell (so PATH picks up bun) and restart Claude Code.
+EOF
   exit 127
 fi
+
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-exec bun "$SCRIPT_DIR/../adapters/claude/server/index.ts"
+exec bun "$SCRIPT_DIR/index.ts"

package/server/memory.ts

@@ -0,0 +1,404 @@
+/**
+ * Cross-session memory — remembers past projects and earlier conversations.
+ *
+ * Memory is stored in ~/.claude-buddy/memory/:
+ *   projects.json  — project records
+ *   bugs.json      — encountered bugs
+ *   preferences.json — user preferences
+ *
+ * All data is local-only. Nothing is sent to any remote service.
+ * Privacy: users can wipe with `rm -rf ~/.claude-buddy/memory`.
+ */
+
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  existsSync,
+} from "fs";
+import { join } from "path";
+import { buddyStateDir } from "./path";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface ProjectMemory {
+  id: string;
+  name: string;
+  path: string;
+  language: string[];      // e.g. ["typescript", "python"]
+  framework?: string;
+  lastSeen: number;        // timestamp
+  noteCount: number;
+  tags: string[];
+  fileCount?: number;      // number of files in project
+}
+
+export interface BugMemory {
+  id: string;
+  projectId: string;
+  errorSignature: string; // hash of error message
+  summary: string;
+  resolved: boolean;
+  resolvedAt?: number;
+  occurrenceCount: number;
+  lastSeen: number;
+  firstSeen: number;
+}
+
+export interface PreferenceMemory {
+  key: string;
+  value: string;
+  context: string;
+  confidence: number;      // 0-1, derived from frequency
+  lastUpdated: number;
+}
+
+// ─── File paths ───────────────────────────────────────────────────────────────
+
+const MEMORY_DIR = join(buddyStateDir(), "memory");
+const PROJECTS_FILE = join(MEMORY_DIR, "projects.json");
+const BUGS_FILE = join(MEMORY_DIR, "bugs.json");
+const PREFERENCES_FILE = join(MEMORY_DIR, "preferences.json");
+
+function ensureDir(): void {
+  mkdirSync(MEMORY_DIR, { recursive: true });
+}
+
+function loadJson<T>(path: string, fallback: T): T {
+  try {
+    if (existsSync(path)) {
+      return JSON.parse(readFileSync(path, "utf8")) as T;
+    }
+  } catch {
+    // corrupted or empty — use fallback
+  }
+  return fallback;
+}
+
+function saveJson<T>(path: string, data: T): void {
+  ensureDir();
+  writeFileSync(path, JSON.stringify(data, null, 2));
+}
+
+// ─── Project memory ──────────────────────────────────────────────────────────
+
+export function loadProjects(): Record<string, ProjectMemory> {
+  return loadJson(PROJECTS_FILE, {});
+}
+
+export function saveProjects(projects: Record<string, ProjectMemory>): void {
+  saveJson(PROJECTS_FILE, projects);
+}
+
+export function getProject(id: string): ProjectMemory | null {
+  const projects = loadProjects();
+  return projects[id] ?? null;
+}
+
+export function updateProject(
+  id: string,
+  updates: Partial<Omit<ProjectMemory, "id">>,
+): ProjectMemory {
+  const projects = loadProjects();
+  const existing = projects[id] ?? {
+    id,
+    name: id,
+    path: "",
+    language: [],
+    lastSeen: Date.now(),
+    noteCount: 0,
+    tags: [],
+  };
+  projects[id] = {
+    ...existing,
+    ...updates,
+    id, // always preserve original id
+    lastSeen: Date.now(),
+  };
+  saveProjects(projects);
+  return projects[id];
+}
+
+// ─── Bug memory ──────────────────────────────────────────────────────────────
+
+export function loadBugs(): Record<string, BugMemory> {
+  return loadJson(BUGS_FILE, {});
+}
+
+export function saveBugs(bugs: Record<string, BugMemory>): void {
+  saveJson(BUGS_FILE, bugs);
+}
+
+export function getBug(id: string): BugMemory | null {
+  const bugs = loadBugs();
+  return bugs[id] ?? null;
+}
+
+/** Find a bug by its error signature hash within a project */
+export function findBugBySignature(
+  projectId: string,
+  errorSignature: string,
+): BugMemory | null {
+  const bugs = loadBugs();
+  return Object.values(bugs).find(
+    (b) => b.projectId === projectId && b.errorSignature === errorSignature,
+  ) ?? null;
+}
+
+export function addBugMemory(
+  projectId: string,
+  errorSignature: string,
+  summary: string,
+): BugMemory {
+  const bugs = loadBugs();
+
+  // Check if this bug already exists
+  const existing = findBugBySignature(projectId, errorSignature);
+  if (existing) {
+    existing.occurrenceCount += 1;
+    existing.lastSeen = Date.now();
+    existing.summary = summary; // update summary with latest
+    saveBugs(bugs);
+    return existing;
+  }
+
+  const id = `${projectId}-${errorSignature.slice(0, 8)}`;
+  const bug: BugMemory = {
+    id,
+    projectId,
+    errorSignature,
+    summary,
+    resolved: false,
+    occurrenceCount: 1,
+    lastSeen: Date.now(),
+    firstSeen: Date.now(),
+  };
+  bugs[id] = bug;
+  saveBugs(bugs);
+  return bug;
+}
+
+export function resolveBug(id: string): BugMemory | null {
+  const bugs = loadBugs();
+  const bug = bugs[id];
+  if (!bug) return null;
+  bug.resolved = true;
+  bug.resolvedAt = Date.now();
+  saveBugs(bugs);
+  return bug;
+}
+
+// ─── Preference memory ─────────────────────────────────────────────────────────
+
+export function loadPreferences(): Record<string, PreferenceMemory> {
+  return loadJson(PREFERENCES_FILE, {});
+}
+
+export function savePreferences(prefs: Record<string, PreferenceMemory>): void {
+  saveJson(PREFERENCES_FILE, prefs);
+}
+
+export function setPreference(
+  key: string,
+  value: string,
+  context: string,
+  confidenceBoost: number = 0.1,
+): PreferenceMemory {
+  const prefs = loadPreferences();
+  const existing = prefs[key];
+
+  if (existing && existing.context === context) {
+    // Same context — increase confidence, update value
+    existing.confidence = Math.min(1, existing.confidence + confidenceBoost);
+    existing.value = value;
+    existing.lastUpdated = Date.now();
+  } else {
+    // New context or different context — create new or merge cautiously
+    const newConf = confidenceBoost;
+    if (existing && existing.confidence > newConf) {
+      // Existing is more confident — don't overwrite
+      existing.lastUpdated = Date.now();
+    } else {
+      prefs[key] = {
+        key,
+        value,
+        context,
+        confidence: newConf,
+        lastUpdated: Date.now(),
+      };
+    }
+  }
+
+  savePreferences(prefs);
+  return prefs[key];
+}
+
+// ─── Consolidation ───────────────────────────────────────────────────────────
+
+/** Simple hash function for error signatures */
+function simpleHash(s: string): string {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    const char = s.charCodeAt(i);
+    h = ((h << 5) - h) + char;
+    h = h & h; // convert to 32-bit integer
+  }
+  return Math.abs(h).toString(16);
+}
+
+/** Extract language signals from text (file extensions) */
+function extractLanguages(text: string): string[] {
+  const extMap: Record<string, string> = {
+    ts: "typescript", tsx: "typescript", js: "javascript", jsx: "javascript",
+    py: "python", rs: "rust", go: "go", java: "java", rb: "ruby",
+    php: "php", c: "c", cpp: "cpp", cs: "csharp", swift: "swift",
+    kt: "kotlin", scala: "scala", r: "r", lua: "lua", pl: "perl",
+    sh: "shell", bash: "shell", zsh: "shell", fish: "shell",
+    sql: "sql", html: "html", css: "css", scss: "scss", json: "json",
+    yaml: "yaml", yml: "yaml", toml: "toml", xml: "xml", md: "markdown",
+  };
+
+  const found = new Set<string>();
+  const extRegex = /\.([a-z]+)/gi;
+  let match;
+  while ((match = extRegex.exec(text)) !== null) {
+    const ext = match[1].toLowerCase();
+    const lang = extMap[ext];
+    if (lang) found.add(lang);
+  }
+  return [...found];
+}
+
+/** Extract package manager / framework signals */
+function extractFramework(text: string): string | undefined {
+  const signals: Record<string, string> = {
+    "package.json": "Node.js", "package-lock.json": "Node.js",
+    "requirements.txt": "Python", "Pipfile": "Python", "pyproject.toml": "Python",
+    "Cargo.toml": "Rust", "Cargo.lock": "Rust",
+    "go.mod": "Go", "go.sum": "Go",
+    "pom.xml": "Java", "build.gradle": "Java",
+    "Gemfile": "Ruby", "Gemfile.lock": "Ruby",
+    "composer.json": "PHP",
+    "swiftpm": "Swift", "Package.swift": "Swift",
+    ".NET": ".NET", "csproj": ".NET",
+  };
+
+  for (const [file, framework] of Object.entries(signals)) {
+    if (text.includes(file)) return framework;
+  }
+  return undefined;
+}
+
+/** Extract project name from path or git remote */
+function extractProjectName(text: string): string | undefined {
+  // Try to find a directory path
+  const pathRegex = /\/([^\/]+)\/(?:src|lib|app|packages|tests?)/gi;
+  let match;
+  while ((match = pathRegex.exec(text)) !== null) {
+    return match[1];
+  }
+
+  // Try git remote
+  const gitRegex = /github\.com[:/]([\w\-\.]+)\/([^\/\s]+)/gi;
+  while ((match = gitRegex.exec(text)) !== null) {
+    return match[2];
+  }
+
+  return undefined;
+}
+
+/** Extract error messages from text */
+function extractErrors(text: string): Array<{ signature: string; summary: string }> {
+  const errors: Array<{ signature: string; summary: string }> = [];
+  // Common error patterns
+  const errorPatterns = [
+    /([A-Z][a-z]+Error: .+)/,
+    /(SyntaxError: .+)/,
+    /(TypeError: .+)/,
+    /(ReferenceError: .+)/,
+    /(Error: .+)/,
+    /(panic: .+)/,
+    /(Exception: .+)/,
+  ];
+
+  for (const pattern of errorPatterns) {
+    let match;
+    const regex = new RegExp(pattern, "gi");
+    while ((match = regex.exec(text)) !== null) {
+      const full = match[0];
+      const signature = simpleHash(full);
+      // Truncate summary for storage
+      const summary = full.slice(0, 200);
+      errors.push({ signature, summary });
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Consolidate memory from a conversation turn.
+ * Called on Stop hook with the assistant's response and user prompt.
+ */
+export function consolidateMemory(
+  assistantMessage: string,
+  userPrompt: string,
+): void {
+  const combined = `${assistantMessage} ${userPrompt}`;
+
+  // Extract project name
+  const projectName = extractProjectName(combined);
+  if (!projectName) return;
+
+  // Extract and update project
+  const languages = extractLanguages(combined);
+  const framework = extractFramework(combined);
+  updateProject(projectName, {
+    name: projectName,
+    language: languages.length > 0 ? languages : undefined,
+    framework,
+  });
+
+  // Extract and store bugs
+  const errors = extractErrors(combined);
+  for (const err of errors) {
+    addBugMemory(projectName, err.signature, err.summary);
+  }
+}
+
+// ─── Retrieval ───────────────────────────────────────────────────────────────
+
+export interface MemoryQuery {
+  project?: string;
+  type?: "projects" | "bugs" | "preferences" | "all";
+  resolved?: boolean; // for bugs
+}
+
+export function queryMemory(query: MemoryQuery): {
+  projects: ProjectMemory[];
+  bugs: BugMemory[];
+  preferences: PreferenceMemory[];
+} {
+  const projects = query.type === "bugs" || query.type === "preferences"
+    ? []
+    : Object.values(loadProjects()).filter(
+        (p) => !query.project || p.id === query.project || p.name.includes(query.project),
+      );
+
+  let bugs = query.type === "projects" || query.type === "preferences"
+    ? []
+    : Object.values(loadBugs());
+
+  if (query.project) {
+    bugs = bugs.filter((b) => b.projectId === query.project);
+  }
+  if (query.resolved !== undefined) {
+    bugs = bugs.filter((b) => b.resolved === query.resolved);
+  }
+
+  const preferences = query.type === "projects" || query.type === "bugs"
+    ? []
+    : Object.values(loadPreferences());
+
+  return { projects, bugs, preferences };
+}

package/server/mood.ts

@@ -0,0 +1,254 @@
+/**
+ * Mood system — buddy情绪 based on coding events and time of day.
+ *
+ * Mood is session-scoped (stored in mood.json, resets on session restart).
+ * Shifts based on: test results, error count, session duration, time of day.
+ * Affects: reaction flavor, stat modifiers, art expression.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { buddyStateDir } from "./path";
+import type { StatName } from "../core/engine.ts"
+
+// ─── Mood types ───────────────────────────────────────────────────────────────
+
+export type Mood =
+  | "happy"      // tests passing, good code
+  | "focused"    // active coding session, good progress
+  | "excited"    // big diff, achievement unlocked, major event
+  | "tired"      // long session, many errors
+  | "melancholy" // repeated failures, low streak
+  | "chaotic";   // many errors in short time, unpredictable
+
+export interface MoodState {
+  current: Mood;
+  since: number;          // timestamp of last mood change
+  intensity: number;        // 1-3, affects how much mood modifies behavior
+  recentErrors: number;     // errors in last 5 minutes
+  recentTests: number;     // tests passed in last 5 minutes
+  recentDiffs: number;     // large diffs in last 5 minutes
+}
+
+// ─── Mood colors (for status line display) ───────────────────────────────────
+
+export const MOOD_COLORS: Record<Mood, string> = {
+  happy:    "\ud83d\ude0a",  // 😀
+  focused: "\ud83e\udd13",  // 🧐
+  excited: "\ud83e\ude74",  // 🥳
+  tired:   "\ud83d\ude34",  // 😴
+  melancholy: "\ud83d\ude14", // 😔
+  chaotic: "\ud83e\udd2f",  // 🤯
+};
+
+export const MOOD_NAMES: Record<Mood, string> = {
+  happy:    "Happy",
+  focused:  "Focused",
+  excited:  "Excited",
+  tired:    "Tired",
+  melancholy: "Melancholy",
+  chaotic:  "Chaotic",
+};
+
+// ─── Time-of-day influence ───────────────────────────────────────────────────
+
+export function getTimeOfDayMood(): Mood {
+  const hour = new Date().getHours();
+  if (hour >= 22 || hour < 6) return "tired";       // late night
+  if (hour >= 6 && hour < 9) return "melancholy";   // early morning
+  if (hour >= 9 && hour < 12) return "focused";     // morning
+  if (hour >= 12 && hour < 17) return "happy";       // afternoon
+  if (hour >= 17 && hour < 20) return "excited";    // evening
+  return "tired";
+}
+
+// ─── Mood persistence ────────────────────────────────────────────────────────
+
+const MOOD_FILE = join(buddyStateDir(), "mood.json");
+
+function loadMoodState(): MoodState {
+  try {
+    return JSON.parse(readFileSync(MOOD_FILE, "utf8")) as MoodState;
+  } catch {
+    return {
+      current: getTimeOfDayMood(),
+      since: Date.now(),
+      intensity: 1,
+      recentErrors: 0,
+      recentTests: 0,
+      recentDiffs: 0,
+    };
+  }
+}
+
+function saveMoodState(state: MoodState): void {
+  mkdirSync(buddyStateDir(), { recursive: true });
+  writeFileSync(MOOD_FILE, JSON.stringify(state, null, 2));
+}
+
+// ─── Mood shift triggers ────────────────────────────────────────────────────
+
+export type MoodTrigger =
+  | "tests_pass"
+  | "tests_fail"
+  | "error"
+  | "large_diff"
+  | "achievement"
+  | "long_session"
+  | "idle"
+  | "rest";
+
+const MOOD_TRANSITIONS: Record<Mood, Partial<Record<MoodTrigger, Mood>>> = {
+  happy: {
+    tests_pass: "excited",
+    achievement: "excited",
+    long_session: "melancholy",
+    error: "tired",
+  },
+  focused: {
+    tests_pass: "happy",
+    error: "tired",
+    long_session: "tired",
+  },
+  excited: {
+    tests_pass: "excited",
+    error: "focused",
+    idle: "happy",
+  },
+  tired: {
+    tests_pass: "focused",
+    error: "chaotic",
+    rest: "happy",
+    idle: "melancholy",
+  },
+  melancholy: {
+    tests_pass: "focused",
+    achievement: "happy",
+    error: "chaotic",
+    rest: "happy",
+  },
+  chaotic: {
+    tests_pass: "focused",
+    idle: "tired",
+    rest: "melancholy",
+    error: "chaotic",
+  },
+};
+
+// ─── Core functions ───────────────────────────────────────────────────────────
+
+const RECENT_WINDOW_MS = 5 * 60 * 1000; // 5 minutes
+
+function decayRecentCounts(state: MoodState): MoodState {
+  // Decay recent counts based on time since last update
+  const elapsed = Date.now() - state.since;
+  if (elapsed > RECENT_WINDOW_MS) {
+    return {
+      ...state,
+      recentErrors: 0,
+      recentTests: 0,
+      recentDiffs: 0,
+      since: Date.now(),
+    };
+  }
+  return state;
+}
+
+/**
+ * Shift mood based on a trigger event.
+ * Returns the new mood state.
+ */
+export function shiftMood(trigger: MoodTrigger): MoodState {
+  let state = loadMoodState();
+  state = decayRecentCounts(state);
+
+  // Update recent counters based on trigger
+  switch (trigger) {
+    case "error":
+      state.recentErrors += 1;
+      break;
+    case "tests_pass":
+      state.recentTests += 1;
+      break;
+    case "large_diff":
+      state.recentDiffs += 1;
+      break;
+  }
+
+  // Check for chaotic threshold (3+ errors in 5 minutes)
+  if (trigger === "error" && state.recentErrors >= 3) {
+    state.current = "chaotic";
+    state.intensity = Math.min(3, state.recentErrors - 1);
+    state.since = Date.now();
+    saveMoodState(state);
+    return state;
+  }
+
+  // Look up the transition for the current mood
+  const transitions = MOOD_TRANSITIONS[state.current];
+  if (transitions && transitions[trigger]) {
+    const newMood = transitions[trigger]!;
+    if (newMood !== state.current) {
+      state.current = newMood;
+      state.intensity = Math.min(3, state.intensity + 1);
+      state.since = Date.now();
+    }
+  }
+
+  saveMoodState(state);
+  return state;
+}
+
+/**
+ * Get the current mood state.
+ */
+export function getMood(): MoodState {
+  return decayRecentCounts(loadMoodState());
+}
+
+/**
+ * Get mood stat modifiers (±5 to effective stats based on mood).
+ * These are temporary and don't persist.
+ */
+export function getMoodModifier(mood: Mood, stat: StatName): number {
+  switch (mood) {
+    case "happy":
+      return stat === "WISDOM" ? +5 : 0;
+    case "focused":
+      return stat === "DEBUGGING" ? +5 : stat === "CHAOS" ? -3 : 0;
+    case "chaotic":
+      return stat === "CHAOS" ? +8 : stat === "WISDOM" ? -5 : 0;
+    case "tired":
+      return stat === "PATIENCE" ? +3 : stat === "DEBUGGING" ? -3 : 0;
+    case "melancholy":
+      return stat === "WISDOM" ? +3 : 0;
+    case "excited":
+      return stat === "CHAOS" ? +5 : stat === "PATIENCE" ? -3 : 0;
+  }
+}
+
+// ─── Mood for reactions ─────────────────────────────────────────────────────
+
+/**
+ * Get a mood-specific reaction suffix/prefix.
+ * Returns undefined if no mood-specific reaction should be used.
+ */
+export function getMoodReaction(mood: Mood): string | undefined {
+  const r = Math.random();
+  if (r > 0.3) return undefined; // 30% chance of mood reaction
+
+  switch (mood) {
+    case "happy":
+      return "*blooms*";
+    case "focused":
+      return "*intensifies*";
+    case "excited":
+      return "*vibrates with energy*";
+    case "tired":
+      return "*yawns*";
+    case "melancholy":
+      return "*sighs gently*";
+    case "chaotic":
+      return "*glitches*";
+  }
+}