clawmini 0.0.1

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "clawmini",
+  "version": "0.0.1",
+  "type": "module",
+  "workspaces": [
+    "web"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tbuckley/clawmini.git"
+  },
+  "bin": {
+    "clawmini": "./dist/cli/index.mjs",
+    "clawmini-adapter-discord": "./dist/adapter-discord/index.mjs"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "tsdown && npm run build:web",
+    "dev:cli": "tsdown --watch",
+    "dev:daemon": "tsdown --watch",
+    "lint": "eslint -f codeframe .",
+    "lint:fix": "eslint . --fix",
+    "format:check": "prettier --check \"src/**/*.ts\" \"web/src/**/*.ts\"",
+    "format": "prettier --write \"src/**/*.ts\" \"web/src/**/*.ts\"",
+    "check": "tsc --noEmit && npm run check -w web",
+    "test": "vitest run && npm run test -w web",
+    "build:web": "npm run build -w web"
+  },
+  "dependencies": {
+    "@trpc/client": "^11.12.0",
+    "@trpc/server": "^11.10.0",
+    "commander": "^14.0.3",
+    "discord.js": "^14.25.1",
+    "node-schedule": "^2.1.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.3.0",
+    "eslint": "^10.0.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-formatter-codeframe": "^7.32.2",
+    "globals": "^17.3.0",
+    "prettier": "^3.8.1",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.1",
+    "vitest": "^4.0.18"
+  }
+}

package/scripts/create_worktree.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+# Check if an argument is provided
+if [ -z "$1" ]; then
+  echo "Usage: $0 <branch-name>"
+  exit 1
+fi
+
+BRANCH_NAME=$1
+# Resolve the target directory relative to the current directory's parent
+TARGET_DIR="../$BRANCH_NAME"
+
+echo "Creating git worktree '$BRANCH_NAME' at '$TARGET_DIR'..."
+# Create the worktree and the new branch
+git worktree add -b "$BRANCH_NAME" "$TARGET_DIR"
+
+if [ $? -ne 0 ]; then
+  echo "Error: Failed to create worktree. Please check git status and arguments."
+  exit 1
+fi
+
+echo "Copying .gemini sandbox files..."
+if [ -d ".gemini" ]; then
+  mkdir -p "$TARGET_DIR/.gemini"
+  if ls .gemini/*.sb 1> /dev/null 2>&1; then
+    cp .gemini/*.sb "$TARGET_DIR/.gemini/"
+  else
+    echo "No .sb files found in .gemini/"
+  fi
+else
+  echo "Warning: .gemini directory not found. Skipping sandbox files copy."
+fi
+
+echo "Running npm install in '$TARGET_DIR'..."
+# Navigate to the new directory and install dependencies
+cd "$TARGET_DIR" || exit 1
+npm install
+
+if [ $? -eq 0 ]; then
+    echo "--------------------------------------------------"
+    echo "Worktree setup complete for '$BRANCH_NAME'."
+    echo "Location: $TARGET_DIR"
+    echo "NOTE: To change your current shell to this directory, run:"
+    echo "source ./scripts/create_worktree.sh $BRANCH_NAME"
+    echo "--------------------------------------------------"
+else
+    echo "Error: npm install failed."
+    exit 1
+fi

package/scripts/get_pr_comments.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+# 1. Check if GitHub CLI is installed
+if ! command -v gh &> /dev/null; then
+    echo "Error: GitHub CLI ('gh') is not installed."
+    exit 1
+fi
+
+# 2. Get the PR Number
+# Accepts a number as an argument (./script.sh 123)
+# OR defaults to the current branch's PR if no argument is provided.
+PR_NUM=${1:-$(gh pr view --json number -q .number 2>/dev/null)}
+
+if [ -z "$PR_NUM" ]; then
+    echo "Error: Could not detect a PR number. Are you on a branch with an open PR?"
+    echo "Usage: $0 [pr-number]"
+    exit 1
+fi
+
+echo "Fetching review comments for PR #$PR_NUM..."
+echo "---------------------------------------------------"
+
+# 3. Fetch Comments via API
+# - GH_PAGER="": Disables interactive pager (less)
+# - --paginate: Ensures we get all comments (not just the first 30)
+# - jq: Formats the raw JSON into readable text
+GH_PAGER="" gh api --paginate \
+  "repos/:owner/:repo/pulls/$PR_NUM/comments" \
+  --jq '.[] | 
+    "File:   \(.path)",
+    "Line:   \(if .line then .line else (.original_line | tostring + " (outdated)") end)",
+    "----",
+    "\(.body)",
+    "\n===================================================\n"'
+
+#     "Author: \(.user.login)",

package/src/adapter-discord/client.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getTRPCClient } from './client.js';
+import fs from 'node:fs';
+import * as workspace from '../shared/workspace.js';
+import { createTRPCClient, httpLink, splitLink, httpSubscriptionLink } from '@trpc/client';
+import { createUnixSocketFetch } from '../shared/fetch.js';
+
+vi.mock('node:fs');
+vi.mock('../shared/workspace.js');
+vi.mock('@trpc/client', () => ({
+  createTRPCClient: vi.fn().mockReturnValue({
+    ping: {
+      query: vi.fn().mockResolvedValue({ status: 'ok' }),
+    },
+  }),
+  httpLink: vi.fn(),
+  splitLink: vi.fn(),
+  httpSubscriptionLink: vi.fn(),
+}));
+vi.mock('../shared/fetch.js', () => ({
+  createUnixSocketFetch: vi.fn(),
+}));
+
+describe('Discord Adapter TRPC Client', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should throw error if daemon socket does not exist', () => {
+    vi.mocked(workspace.getSocketPath).mockReturnValue('/tmp/test.sock');
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    expect(() => getTRPCClient()).toThrow('Daemon not running. Socket not found at /tmp/test.sock');
+  });
+
+  it('should create TRPC client if daemon socket exists', () => {
+    vi.mocked(workspace.getSocketPath).mockReturnValue('/tmp/test.sock');
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+
+    const client = getTRPCClient();
+    expect(client).toBeDefined();
+    expect(createTRPCClient).toHaveBeenCalled();
+    expect(splitLink).toHaveBeenCalled();
+    expect(httpLink).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'http://localhost',
+      })
+    );
+    expect(httpSubscriptionLink).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'http://localhost',
+      })
+    );
+    expect(createUnixSocketFetch).toHaveBeenCalledWith('/tmp/test.sock');
+  });
+
+  it('should be able to call ping on the client', async () => {
+    vi.mocked(workspace.getSocketPath).mockReturnValue('/tmp/test.sock');
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+
+    const client = getTRPCClient();
+    const result = await client.ping.query();
+    expect(result).toEqual({ status: 'ok' });
+  });
+});

package/src/adapter-discord/client.ts

@@ -0,0 +1,41 @@
+import { createTRPCClient, httpLink, splitLink, httpSubscriptionLink } from '@trpc/client';
+import type { AppRouter } from '../daemon/router.js';
+import { getSocketPath } from '../shared/workspace.js';
+import { createUnixSocketFetch } from '../shared/fetch.js';
+import { createUnixSocketEventSource } from '../shared/event-source.js';
+import fs from 'node:fs';
+
+/**
+ * Creates a TRPC client that connects to the Clawmini daemon via a Unix socket.
+ *
+ * @param options - Configuration options for the client.
+ * @returns A TRPC client instance for the AppRouter.
+ */
+export function getTRPCClient(options: { socketPath?: string } = {}) {
+  const socketPath = options.socketPath ?? getSocketPath();
+
+  if (!fs.existsSync(socketPath)) {
+    throw new Error(`Daemon not running. Socket not found at ${socketPath}`);
+  }
+
+  const customFetch = createUnixSocketFetch(socketPath);
+  const CustomEventSource = createUnixSocketEventSource(socketPath);
+
+  return createTRPCClient<AppRouter>({
+    links: [
+      splitLink({
+        condition(op) {
+          return op.type === 'subscription';
+        },
+        true: httpSubscriptionLink({
+          url: 'http://localhost',
+          EventSource: CustomEventSource,
+        }),
+        false: httpLink({
+          url: 'http://localhost',
+          fetch: customFetch,
+        }),
+      }),
+    ],
+  });
+}

package/src/adapter-discord/config.test.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import fsPromises from 'node:fs/promises';
+import {
+  DiscordConfigSchema,
+  isAuthorized,
+  readDiscordConfig,
+  getDiscordConfigPath,
+} from './config.js';
+
+vi.mock('node:fs/promises');
+vi.mock('node:fs', () => ({
+  default: {
+    existsSync: vi.fn(),
+  },
+  existsSync: vi.fn(),
+}));
+vi.mock('../shared/workspace.js', () => ({
+  getClawminiDir: () => '/mock/clawmini',
+}));
+
+describe('Discord Adapter Configuration', () => {
+  describe('DiscordConfigSchema', () => {
+    it('should validate a correct configuration', () => {
+      const config = {
+        botToken: 'my-bot-token',
+        authorizedUserId: '1234567890',
+      };
+      const result = DiscordConfigSchema.safeParse(config);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data).toEqual({
+          ...config,
+          chatId: 'default',
+          maxAttachmentSizeMB: 25,
+        });
+      }
+    });
+
+    it('should validate a custom maxAttachmentSizeMB', () => {
+      const config = {
+        botToken: 'my-bot-token',
+        authorizedUserId: '1234567890',
+        maxAttachmentSizeMB: 50,
+      };
+      const result = DiscordConfigSchema.safeParse(config);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.maxAttachmentSizeMB).toBe(50);
+      }
+    });
+
+    it('should fail validation if fields are missing', () => {
+      const result = DiscordConfigSchema.safeParse({});
+      expect(result.success).toBe(false);
+    });
+
+    it('should fail validation if fields are empty', () => {
+      const result = DiscordConfigSchema.safeParse({
+        botToken: '',
+        authorizedUserId: '',
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('isAuthorized', () => {
+    it('should return true if user ID matches authorized user ID', () => {
+      expect(isAuthorized('123', '123')).toBe(true);
+    });
+
+    it('should return false if user ID does not match', () => {
+      expect(isAuthorized('123', '456')).toBe(false);
+    });
+  });
+
+  describe('initDiscordConfig', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let fsMock: any;
+
+    beforeEach(async () => {
+      vi.clearAllMocks();
+      fsMock = await import('node:fs');
+      vi.mocked(fsMock.existsSync).mockReturnValue(false);
+      if (fsMock.default) {
+        vi.mocked(fsMock.default.existsSync).mockReturnValue(false);
+      }
+    });
+
+    it('should create directory and template config file if they do not exist', async () => {
+      const { initDiscordConfig } = await import('./config.js');
+      await initDiscordConfig();
+
+      expect(fsPromises.mkdir).toHaveBeenCalledWith('/mock/clawmini/adapters/discord', {
+        recursive: true,
+      });
+      expect(fsPromises.writeFile).toHaveBeenCalled();
+      const writeCall = vi.mocked(fsPromises.writeFile).mock.calls[0];
+      expect(writeCall![0]).toBe(getDiscordConfigPath());
+      expect(JSON.parse(writeCall![1] as string)).toEqual({
+        botToken: 'YOUR_DISCORD_BOT_TOKEN',
+        authorizedUserId: 'YOUR_DISCORD_USER_ID',
+        chatId: 'default',
+      });
+    });
+
+    it('should not overwrite existing config file', async () => {
+      vi.mocked(fsMock.existsSync).mockReturnValue(true);
+      if (fsMock.default) {
+        vi.mocked(fsMock.default.existsSync).mockReturnValue(true);
+      }
+      const { initDiscordConfig } = await import('./config.js');
+      await initDiscordConfig();
+
+      expect(fsPromises.writeFile).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('readDiscordConfig', () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    it('should successfully read and parse a valid config file', async () => {
+      const mockConfig = {
+        botToken: 'my-bot-token',
+        authorizedUserId: '1234567890',
+      };
+      vi.mocked(fsPromises.readFile).mockResolvedValue(JSON.stringify(mockConfig));
+
+      const config = await readDiscordConfig();
+      expect(config).toEqual({ ...mockConfig, chatId: 'default', maxAttachmentSizeMB: 25 });
+      expect(fsPromises.readFile).toHaveBeenCalledWith(getDiscordConfigPath(), 'utf-8');
+    });
+
+    it('should return null if the config file does not exist', async () => {
+      vi.mocked(fsPromises.readFile).mockRejectedValue(new Error('File not found'));
+
+      const config = await readDiscordConfig();
+      expect(config).toBeNull();
+    });
+
+    it('should return null if the config file contains invalid JSON', async () => {
+      vi.mocked(fsPromises.readFile).mockResolvedValue('invalid-json');
+
+      const config = await readDiscordConfig();
+      expect(config).toBeNull();
+    });
+
+    it('should return null if the config fails schema validation', async () => {
+      vi.mocked(fsPromises.readFile).mockResolvedValue(JSON.stringify({ botToken: 'test' }));
+
+      const config = await readDiscordConfig();
+      expect(config).toBeNull();
+    });
+  });
+});

package/src/adapter-discord/config.ts

@@ -0,0 +1,61 @@
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { getClawminiDir } from '../shared/workspace.js';
+import fs from 'node:fs';
+
+export const DiscordConfigSchema = z.looseObject({
+  botToken: z.string().min(1, 'Discord Bot Token is required.'),
+  authorizedUserId: z.string().min(1, 'Authorized Discord User ID is required.'),
+  chatId: z.string().default('default'),
+  maxAttachmentSizeMB: z.number().default(25).optional(),
+});
+
+export type DiscordConfig = z.infer<typeof DiscordConfigSchema>;
+
+export function getDiscordConfigPath(startDir = process.cwd()): string {
+  return path.join(getClawminiDir(startDir), 'adapters', 'discord', 'config.json');
+}
+
+export async function readDiscordConfig(startDir = process.cwd()): Promise<DiscordConfig | null> {
+  const configPath = getDiscordConfigPath(startDir);
+  try {
+    const data = await fsPromises.readFile(configPath, 'utf-8');
+    const parsed = JSON.parse(data);
+    const result = DiscordConfigSchema.safeParse(parsed);
+    if (!result.success) {
+      console.error('Invalid Discord configuration:', result.error.format());
+      return null;
+    }
+    return result.data;
+  } catch {
+    // Return null if file doesn't exist or is invalid JSON
+    return null;
+  }
+}
+
+export async function initDiscordConfig(startDir = process.cwd()): Promise<void> {
+  const configPath = getDiscordConfigPath(startDir);
+  const configDir = path.dirname(configPath);
+
+  await fsPromises.mkdir(configDir, { recursive: true });
+
+  if (fs.existsSync(configPath)) {
+    console.log(`Config file already exists at ${configPath}`);
+    return;
+  }
+
+  const templateConfig = {
+    botToken: 'YOUR_DISCORD_BOT_TOKEN',
+    authorizedUserId: 'YOUR_DISCORD_USER_ID',
+    chatId: 'default',
+  };
+
+  await fsPromises.writeFile(configPath, JSON.stringify(templateConfig, null, 2), 'utf-8');
+  console.log(`Created template configuration file at ${configPath}`);
+  console.log('Please update it with your actual Discord Bot Token and User ID.');
+}
+
+export function isAuthorized(userId: string, authorizedUserId: string): boolean {
+  return userId === authorizedUserId;
+}