goatcode-sh 0.0.1 → 0.1.2

package/src/features/session-state/session-cursor.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { consumeNewMessages, resetMessageCursor } from "./session-cursor";
+
+describe("session-cursor", () => {
+  beforeEach(() => {
+    resetMessageCursor();
+  });
+
+  describe("#given no prior cursor state", () => {
+    describe("#when consumeNewMessages is called with messages", () => {
+      it("#then returns all messages on first call", () => {
+        const messages = [
+          { info: { id: "msg-1" } },
+          { info: { id: "msg-2" } },
+          { info: { id: "msg-3" } },
+        ];
+
+        const result = consumeNewMessages("session-1", messages);
+        expect(result).toHaveLength(3);
+        expect(result).toEqual(messages);
+      });
+    });
+
+    describe("#when consumeNewMessages is called with empty array", () => {
+      it("#then returns empty array", () => {
+        const result = consumeNewMessages("session-1", []);
+        expect(result).toHaveLength(0);
+      });
+    });
+
+    describe("#when sessionId is undefined", () => {
+      it("#then returns all messages without tracking", () => {
+        const messages = [{ info: { id: "msg-1" } }, { info: { id: "msg-2" } }];
+        const result = consumeNewMessages(undefined, messages);
+        expect(result).toHaveLength(2);
+      });
+    });
+  });
+
+  describe("#given messages already consumed", () => {
+    describe("#when consumeNewMessages is called again with same messages", () => {
+      it("#then returns empty array (no new messages)", () => {
+        const messages = [{ info: { id: "msg-1" } }, { info: { id: "msg-2" } }];
+
+        consumeNewMessages("session-2", messages);
+        const result = consumeNewMessages("session-2", messages);
+
+        expect(result).toHaveLength(0);
+      });
+    });
+
+    describe("#when consumeNewMessages is called with additional messages", () => {
+      it("#then returns only the new messages", () => {
+        const initial = [{ info: { id: "msg-1" } }, { info: { id: "msg-2" } }];
+        const extended = [
+          { info: { id: "msg-1" } },
+          { info: { id: "msg-2" } },
+          { info: { id: "msg-3" } },
+          { info: { id: "msg-4" } },
+        ];
+
+        consumeNewMessages("session-3", initial);
+        const result = consumeNewMessages("session-3", extended);
+
+        expect(result).toHaveLength(2);
+        expect(result[0].info?.id).toBe("msg-3");
+        expect(result[1].info?.id).toBe("msg-4");
+      });
+    });
+
+    describe("#when message list shrinks (history reset)", () => {
+      it("#then returns all messages from the beginning", () => {
+        const large = [
+          { info: { id: "msg-1" } },
+          { info: { id: "msg-2" } },
+          { info: { id: "msg-3" } },
+        ];
+        const small = [{ info: { id: "msg-new-1" } }];
+
+        consumeNewMessages("session-4", large);
+        const result = consumeNewMessages("session-4", small);
+
+        expect(result).toHaveLength(1);
+        expect(result[0].info?.id).toBe("msg-new-1");
+      });
+    });
+  });
+
+  describe("#given messages with timestamp-based keys", () => {
+    describe("#when consumeNewMessages is called with time-based messages", () => {
+      it("#then tracks cursor by timestamp", () => {
+        const initial = [{ info: { time: 1000 } }, { info: { time: 2000 } }];
+        const extended = [
+          { info: { time: 1000 } },
+          { info: { time: 2000 } },
+          { info: { time: 3000 } },
+        ];
+
+        consumeNewMessages("session-5", initial);
+        const result = consumeNewMessages("session-5", extended);
+
+        expect(result).toHaveLength(1);
+        expect(result[0].info?.time).toBe(3000);
+      });
+    });
+  });
+
+  describe("#given a cursor that was reset", () => {
+    describe("#when resetMessageCursor is called for a specific session", () => {
+      it("#then that session returns all messages again", () => {
+        const messages = [{ info: { id: "msg-1" } }, { info: { id: "msg-2" } }];
+
+        consumeNewMessages("session-6", messages);
+        resetMessageCursor("session-6");
+
+        const result = consumeNewMessages("session-6", messages);
+        expect(result).toHaveLength(2);
+      });
+    });
+
+    describe("#when resetMessageCursor is called without session ID", () => {
+      it("#then all sessions return all messages again", () => {
+        const messages = [{ info: { id: "msg-1" } }];
+
+        consumeNewMessages("session-7", messages);
+        consumeNewMessages("session-8", messages);
+        resetMessageCursor();
+
+        const result7 = consumeNewMessages("session-7", messages);
+        const result8 = consumeNewMessages("session-8", messages);
+
+        expect(result7).toHaveLength(1);
+        expect(result8).toHaveLength(1);
+      });
+    });
+  });
+});

package/src/features/session-state/session-cursor.ts

@@ -0,0 +1,80 @@
+type MessageTime = { created?: number | string } | number | string | undefined;
+
+type MessageInfo = {
+  id?: string;
+  time?: MessageTime;
+};
+
+export type CursorMessage = {
+  info?: MessageInfo;
+};
+
+interface CursorState {
+  lastKey?: string;
+  lastCount: number;
+}
+
+const sessionCursors = new Map<string, CursorState>();
+
+function buildMessageKey(message: CursorMessage, index: number): string {
+  const id = message.info?.id;
+  if (id) return `id:${id}`;
+
+  const time = message.info?.time;
+  if (typeof time === "number" || typeof time === "string") {
+    return `t:${time}:${index}`;
+  }
+
+  const created = (time as { created?: number | string } | undefined)?.created;
+  if (typeof created === "number") {
+    return `t:${created}:${index}`;
+  }
+  if (typeof created === "string") {
+    return `t:${created}:${index}`;
+  }
+
+  return `i:${index}`;
+}
+
+export function consumeNewMessages<T extends CursorMessage>(
+  sessionId: string | undefined,
+  messages: T[],
+): T[] {
+  if (!sessionId) return messages;
+
+  const keys = messages.map((message, index) => buildMessageKey(message, index));
+  const cursor = sessionCursors.get(sessionId);
+  let startIndex = 0;
+
+  if (cursor) {
+    if (cursor.lastCount > messages.length) {
+      startIndex = 0;
+    } else if (cursor.lastKey) {
+      const lastIndex = keys.lastIndexOf(cursor.lastKey);
+      if (lastIndex >= 0) {
+        startIndex = lastIndex + 1;
+      } else {
+        startIndex = 0;
+      }
+    }
+  }
+
+  if (messages.length === 0) {
+    sessionCursors.delete(sessionId);
+  } else {
+    sessionCursors.set(sessionId, {
+      lastKey: keys[keys.length - 1],
+      lastCount: messages.length,
+    });
+  }
+
+  return messages.slice(startIndex);
+}
+
+export function resetMessageCursor(sessionId?: string): void {
+  if (sessionId) {
+    sessionCursors.delete(sessionId);
+    return;
+  }
+  sessionCursors.clear();
+}

package/src/features/session-state/session-store.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import {
+  setSessionState,
+  getSessionState,
+  deleteSessionState,
+  clearSessionStore,
+} from "./session-store";
+
+describe("session-store", () => {
+  beforeEach(() => {
+    clearSessionStore();
+  });
+
+  describe("#given a new session ID", () => {
+    describe("#when setSessionState is called", () => {
+      it("#then creates a new session entry with defaults", () => {
+        const before = Date.now();
+        setSessionState("session-1", { model: "claude-opus", status: "active" });
+        const after = Date.now();
+
+        const state = getSessionState("session-1");
+        expect(state).toBeDefined();
+        expect(state?.sessionId).toBe("session-1");
+        expect(state?.model).toBe("claude-opus");
+        expect(state?.status).toBe("active");
+        expect(state?.createdAt).toBeGreaterThanOrEqual(before);
+        expect(state?.createdAt).toBeLessThanOrEqual(after);
+        expect(state?.updatedAt).toBeGreaterThanOrEqual(before);
+        expect(state?.updatedAt).toBeLessThanOrEqual(after);
+      });
+    });
+
+    describe("#when getSessionState is called before any set", () => {
+      it("#then returns undefined", () => {
+        const state = getSessionState("nonexistent");
+        expect(state).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given an existing session", () => {
+    describe("#when setSessionState is called again", () => {
+      it("#then updates fields while preserving createdAt", () => {
+        setSessionState("session-2", { model: "gpt-4", status: "active" });
+        const first = getSessionState("session-2");
+        const originalCreatedAt = first?.createdAt;
+
+        setSessionState("session-2", { status: "idle" });
+        const updated = getSessionState("session-2");
+
+        expect(updated?.createdAt).toBe(originalCreatedAt);
+        expect(updated?.status).toBe("idle");
+        expect(updated?.model).toBe("gpt-4");
+        expect(updated?.updatedAt).toBeGreaterThanOrEqual(first?.updatedAt ?? 0);
+      });
+    });
+
+    describe("#when deleteSessionState is called", () => {
+      it("#then removes the session entry", () => {
+        setSessionState("session-3", { agent: "sisyphus" });
+        expect(getSessionState("session-3")).toBeDefined();
+
+        deleteSessionState("session-3");
+        expect(getSessionState("session-3")).toBeUndefined();
+      });
+    });
+  });
+
+  describe("#given multiple sessions", () => {
+    describe("#when clearSessionStore is called", () => {
+      it("#then removes all session entries", () => {
+        setSessionState("session-a", { model: "claude" });
+        setSessionState("session-b", { model: "gpt" });
+
+        clearSessionStore();
+
+        expect(getSessionState("session-a")).toBeUndefined();
+        expect(getSessionState("session-b")).toBeUndefined();
+      });
+    });
+  });
+});

package/src/features/session-state/session-store.ts

@@ -0,0 +1,37 @@
+export interface SessionState {
+  sessionId: string;
+  model?: string;
+  agent?: string;
+  status?: "active" | "idle" | "completed";
+  createdAt: number;
+  updatedAt: number;
+}
+
+const store = new Map<string, SessionState>();
+
+export function setSessionState(
+  sessionId: string,
+  state: Partial<Omit<SessionState, "sessionId" | "createdAt">>,
+): void {
+  const existing = store.get(sessionId);
+  const now = Date.now();
+  store.set(sessionId, {
+    ...existing,
+    ...state,
+    sessionId,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+  });
+}
+
+export function getSessionState(sessionId: string): SessionState | undefined {
+  return store.get(sessionId);
+}
+
+export function deleteSessionState(sessionId: string): void {
+  store.delete(sessionId);
+}
+
+export function clearSessionStore(): void {
+  store.clear();
+}

package/src/features/session-state/session-tools-store.ts

@@ -0,0 +1,18 @@
+const store = new Map<string, Record<string, boolean>>();
+
+export function setSessionTools(sessionId: string, tools: Record<string, boolean>): void {
+  store.set(sessionId, { ...tools });
+}
+
+export function getSessionTools(sessionId: string): Record<string, boolean> | undefined {
+  const tools = store.get(sessionId);
+  return tools ? { ...tools } : undefined;
+}
+
+export function deleteSessionTools(sessionId: string): void {
+  store.delete(sessionId);
+}
+
+export function clearSessionTools(): void {
+  store.clear();
+}

package/src/features/skills/builtin/git-master.ts

@@ -0,0 +1,109 @@
+import type { Skill } from "../skill-loader";
+
+export const gitMasterSkill: Skill = {
+  name: "git-master",
+  description:
+    "MUST USE for any git operations. Atomic commits, branch strategy, rebase safety, and PR readiness workflow.",
+  template: `# Git Master
+
+You are a Git specialist focused on clean history, safe collaboration, and reviewer-friendly pull requests.
+
+## Operating Principles
+
+1. Make atomic commits that can be reverted independently.
+2. Keep branch history readable for reviewers.
+3. Never run destructive git commands unless explicitly asked.
+4. Prefer safe defaults: \`--force-with-lease\` over \`--force\`, never rewrite shared main/master history.
+
+## Commit Strategy
+
+### Before committing
+
+- Inspect status and both staged/unstaged diff.
+- Detect existing commit-message style from recent history.
+- Group changes by concern, not by file extension.
+- Pair implementation and tests in the same commit.
+
+### Atomic grouping rules
+
+- 3+ changed files across unrelated concerns must be split.
+- Different directories generally imply different commits.
+- A commit message should explain intent and impact, not file list.
+
+### Message style
+
+- Follow repository conventions (semantic or plain style based on git log).
+- Keep messages concise and specific.
+- Avoid vague messages like "update" or "fix stuff".
+
+## Branch Naming
+
+Use descriptive branch names:
+
+- \`feat/<short-feature>\`
+- \`fix/<bug-summary>\`
+- \`refactor/<scope>\`
+- \`chore/<task>\`
+
+Examples:
+
+- \`feat/skill-loader-project-overrides\`
+- \`fix/retry-timeout-handling\`
+
+## Rebase and History Cleanup
+
+### Safe rebase policy
+
+- Never rebase main/master directly.
+- Rebase feature branches onto latest base branch before PR.
+- If branch was pushed and rewritten, communicate clearly and use \`--force-with-lease\`.
+
+### Conflict handling
+
+1. Resolve conflicts file-by-file.
+2. Keep intended behavior and tests intact.
+3. Run validation again after conflict resolution.
+
+## Pull Request Workflow
+
+### Pre-PR checklist
+
+- Working tree clean.
+- Typecheck and tests pass.
+- Commits are logically split and ordered.
+- PR diff is scoped and reviewable.
+
+### PR content
+
+- Title: concise summary of user value.
+- Body should include:
+  - Summary
+  - Validation done
+  - Risks / follow-ups
+
+## Safety Rules
+
+- Never commit secrets (\`.env\`, credential files, tokens).
+- Never bypass hooks unless explicitly requested.
+- Never force-push to main/master.
+- Prefer a new commit over amend after hook failure.
+
+## Quick Command Sequence
+
+\`\`\`bash
+git status
+git diff --staged --stat
+git diff --stat
+git log -20 --pretty=format:"%s"
+\`\`\`
+
+Then create focused commits in dependency order and verify with:
+
+\`\`\`bash
+git status
+git log --oneline --decorate -20
+\`\`\`
+
+Apply this workflow for all git operations unless the user gives explicit alternative constraints.
+`,
+};

package/src/features/skills/index.ts

@@ -0,0 +1,97 @@
+import { mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { log } from "../../shared/logger";
+import { getDataDir } from "../../shared/data-path";
+import { gitMasterSkill } from "./builtin/git-master";
+import {
+  createProjectSkillLoader,
+  loadProjectSkills,
+  type Skill,
+  type SkillLoader,
+} from "./skill-loader";
+import { mergeSkills } from "./skill-merger";
+import * as skillHandler from "../../tools/skill/handler";
+
+export { gitMasterSkill } from "./builtin/git-master";
+export { createProjectSkillLoader, loadProjectSkills } from "./skill-loader";
+export { mergeSkills } from "./skill-merger";
+export type { Skill, SkillInfo, SkillLoader } from "./skill-loader";
+
+export function getBuiltinSkills(): Skill[] {
+  return [gitMasterSkill];
+}
+
+function skillToMarkdown(skill: Skill): string {
+  return `---\nname: ${skill.name}\ndescription: ${skill.description}\n---\n\n${skill.template.trim()}\n`;
+}
+
+export function getBuiltinSkillsDir(): string | null {
+  try {
+    return join(getDataDir(), "goatcode-sh", "skills");
+  } catch (err) {
+    log("[skills] Failed to resolve built-in skills directory", { err });
+    return null;
+  }
+}
+
+export function syncBuiltinSkillFiles(): string | null {
+  const skillsDir = getBuiltinSkillsDir();
+  if (!skillsDir) return null;
+
+  const builtinSkills = getBuiltinSkills();
+  const expected = new Set(builtinSkills.map((skill) => skill.name));
+  let syncFailed = false;
+
+  try {
+    mkdirSync(skillsDir, { recursive: true });
+    for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
+      if (entry.isDirectory() && !expected.has(entry.name)) {
+        rmSync(join(skillsDir, entry.name), { recursive: true, force: true });
+      }
+    }
+  } catch (err) {
+    syncFailed = true;
+    log("[skills] Failed to reconcile built-in skills directory", { err });
+  }
+
+  for (const skill of builtinSkills) {
+    const skillDir = join(skillsDir, skill.name);
+    const skillFile = join(skillDir, "SKILL.md");
+
+    try {
+      mkdirSync(skillDir, { recursive: true });
+      writeFileSync(skillFile, skillToMarkdown(skill), "utf8");
+    } catch (err) {
+      syncFailed = true;
+      log(`[skills] Failed to write skill file: ${skillFile}`, { err });
+    }
+  }
+  return syncFailed ? null : skillsDir;
+}
+
+export function createMergedSkillLoader(directory: string): SkillLoader {
+  const projectSkills = loadProjectSkills(directory);
+  const mergedSkills = mergeSkills(getBuiltinSkills(), projectSkills);
+  const byName = new Map(mergedSkills.map((skill) => [skill.name, skill.template]));
+
+  return {
+    load(name: string): string | undefined {
+      return byName.get(name);
+    },
+    list() {
+      return mergedSkills.map((s) => ({ name: s.name, description: s.description }));
+    },
+  };
+}
+
+export function registerProjectSkillLoader(directory: string): void {
+  syncBuiltinSkillFiles();
+
+  if (typeof skillHandler.registerSkillLoader === "function") {
+    const loader = createMergedSkillLoader(directory);
+    skillHandler.registerSkillLoader(loader);
+    return;
+  }
+
+  log("[skills] registerSkillLoader not available in handler module");
+}

package/src/features/skills/skill-loader.ts

@@ -0,0 +1,133 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { log } from "../../shared/logger";
+
+export type Skill = {
+  name: string;
+  description: string;
+  template: string;
+};
+
+export type SkillInfo = {
+  name: string;
+  description: string;
+};
+
+export type SkillLoader = {
+  load(name: string): string | undefined;
+  list(): SkillInfo[];
+};
+
+type ParsedSkillFrontmatter = {
+  name?: string;
+  description?: string;
+  body: string;
+};
+
+const SKILLS_RELATIVE_DIR = ".opencode/skills";
+
+export function parseSkillMarkdown(markdown: string): ParsedSkillFrontmatter {
+  const normalized = markdown.replace(/\r\n/g, "\n");
+  if (!normalized.startsWith("---\n")) {
+    return { body: normalized.trim() };
+  }
+
+  const closingIndex = normalized.indexOf("\n---\n", 4);
+  if (closingIndex < 0) {
+    return { body: normalized.trim() };
+  }
+
+  const frontmatterBlock = normalized.slice(4, closingIndex);
+  const body = normalized.slice(closingIndex + 5).trim();
+  const parsed: ParsedSkillFrontmatter = { body };
+
+  for (const line of frontmatterBlock.split("\n")) {
+    const separatorIndex = line.indexOf(":");
+    if (separatorIndex <= 0) {
+      continue;
+    }
+
+    const key = line.slice(0, separatorIndex).trim();
+    const rawValue = line.slice(separatorIndex + 1).trim();
+    const value = stripSurroundingQuotes(rawValue);
+
+    if (key === "name") {
+      parsed.name = value;
+      continue;
+    }
+
+    if (key === "description") {
+      parsed.description = value;
+    }
+  }
+
+  return parsed;
+}
+
+export function loadProjectSkills(directory: string): Skill[] {
+  const skillsDir = join(directory, SKILLS_RELATIVE_DIR);
+  if (!existsSync(skillsDir)) {
+    return [];
+  }
+
+  const files = readdirSync(skillsDir).filter((entry) => entry.endsWith(".md"));
+  const skills: Skill[] = [];
+
+  for (const fileName of files) {
+    const filePath = join(skillsDir, fileName);
+
+    try {
+      const content = readFileSync(filePath, "utf8");
+      const parsed = parseSkillMarkdown(content);
+      const fallbackName = basename(fileName, ".md");
+      const name = parsed.name?.trim() || fallbackName;
+      const description = parsed.description?.trim() || "";
+      const template = parsed.body.trim();
+
+      if (!name || !template) {
+        log("[skills] skipped invalid project skill", {
+          filePath,
+          name,
+          hasTemplate: template.length > 0,
+        });
+        continue;
+      }
+
+      skills.push({ name, description, template });
+    } catch (error) {
+      log("[skills] failed to load project skill file", { filePath, error });
+    }
+  }
+
+  return skills;
+}
+
+export function createProjectSkillLoader(directory: string): SkillLoader {
+  const skills = loadProjectSkills(directory);
+  const byName = new Map(skills.map((skill) => [skill.name, skill.template]));
+
+  return {
+    load(name: string): string | undefined {
+      return byName.get(name);
+    },
+    list(): SkillInfo[] {
+      return skills.map((s) => ({ name: s.name, description: s.description }));
+    },
+  };
+}
+
+function stripSurroundingQuotes(value: string): string {
+  if (value.length < 2) {
+    return value;
+  }
+
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+
+  if (value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+
+  return value;
+}