@assistkick/create 1.0.1 → 1.3.0

package/templates/assistkick-product-system/packages/backend/src/services/project_workspace_service.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, mock, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { ProjectWorkspaceService } from './project_workspace_service.ts';
+import { join } from 'node:path';
+
+const PROJECT_ROOT = '/tmp/test-project-root';
+
+const createMockClaudeService = () => ({
+  spawnCommand: mock.fn(async () => ''),
+});
+
+const createService = (claudeService: any) => {
+  return new ProjectWorkspaceService({
+    claudeService,
+    projectRoot: PROJECT_ROOT,
+    log: mock.fn(),
+  });
+};
+
+describe('ProjectWorkspaceService', () => {
+  let claudeService: ReturnType<typeof createMockClaudeService>;
+  let service: ProjectWorkspaceService;
+
+  beforeEach(() => {
+    claudeService = createMockClaudeService();
+    service = createService(claudeService);
+  });
+
+  describe('getWorkspacePath', () => {
+    it('returns correct workspace path for a project', () => {
+      const path = service.getWorkspacePath('proj_abc123');
+      assert.equal(path, join(PROJECT_ROOT, 'workspaces', 'proj_abc123'));
+    });
+  });
+
+  describe('getWorktreesDir', () => {
+    it('returns correct worktrees dir inside workspace', () => {
+      const path = service.getWorktreesDir('proj_abc123');
+      assert.equal(path, join(PROJECT_ROOT, 'workspaces', 'proj_abc123', '.worktrees'));
+    });
+  });
+
+  describe('getDefaultBranch', () => {
+    it('parses symbolic-ref output correctly', async () => {
+      claudeService.spawnCommand = mock.fn(async (_cmd: string, args: string[]) => {
+        if (args.includes('symbolic-ref')) return 'origin/main\n';
+        return '';
+      });
+
+      const branch = await service.getDefaultBranch('proj_abc123');
+      assert.equal(branch, 'main');
+    });
+
+    it('falls back to branch --show-current', async () => {
+      let callCount = 0;
+      claudeService.spawnCommand = mock.fn(async (_cmd: string, args: string[]) => {
+        callCount++;
+        if (args.includes('symbolic-ref')) throw new Error('no remote');
+        if (args.includes('--show-current')) return 'develop\n';
+        return '';
+      });
+
+      const branch = await service.getDefaultBranch('proj_abc123');
+      assert.equal(branch, 'develop');
+    });
+
+    it('falls back to "main" when all methods fail', async () => {
+      claudeService.spawnCommand = mock.fn(async () => {
+        throw new Error('git failed');
+      });
+
+      const branch = await service.getDefaultBranch('proj_abc123');
+      assert.equal(branch, 'main');
+    });
+  });
+
+  describe('getStatus', () => {
+    it('returns hasWorkspace false when no .git directory', async () => {
+      // existsSync will return false for non-existent paths
+      const status = await service.getStatus('proj_nonexistent');
+      assert.equal(status.hasWorkspace, false);
+      assert.equal(status.hasRemote, false);
+      assert.equal(status.currentBranch, null);
+      assert.equal(status.remoteUrl, null);
+    });
+  });
+});

package/templates/assistkick-product-system/packages/backend/src/services/project_workspace_service.ts

@@ -0,0 +1,194 @@
+/**
+ * ProjectWorkspaceService — manages per-project workspace directories.
+ * Each project gets a workspace at <projectRoot>/workspaces/<projectId>/.
+ * If a remote git repo is connected, it is cloned there.
+ * If not, git init creates a local repo so worktrees and branching always work.
+ */
+
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+
+interface ProjectWorkspaceServiceDeps {
+  claudeService: { spawnCommand: (cmd: string, args: string[], cwd: string) => Promise<string> };
+  projectRoot: string;
+  log: (tag: string, ...args: any[]) => void;
+}
+
+export class ProjectWorkspaceService {
+  private readonly claudeService: ProjectWorkspaceServiceDeps['claudeService'];
+  private readonly projectRoot: string;
+  private readonly log: ProjectWorkspaceServiceDeps['log'];
+
+  constructor({ claudeService, projectRoot, log }: ProjectWorkspaceServiceDeps) {
+    this.claudeService = claudeService;
+    this.projectRoot = projectRoot;
+    this.log = log;
+  }
+
+  /** Get the workspace directory path for a project. */
+  getWorkspacePath = (projectId: string): string => {
+    return join(this.projectRoot, 'workspaces', projectId);
+  };
+
+  /** Get the worktrees directory inside a project workspace. */
+  getWorktreesDir = (projectId: string): string => {
+    return join(this.getWorkspacePath(projectId), '.worktrees');
+  };
+
+  /** Check if a workspace exists and has a git repo. */
+  hasWorkspace = (projectId: string): boolean => {
+    const wsPath = this.getWorkspacePath(projectId);
+    return existsSync(join(wsPath, '.git'));
+  };
+
+  /** Ensure the workspace directory exists. Creates it if missing. */
+  private ensureDir = async (dir: string): Promise<void> => {
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+  };
+
+  /** Initialize a new empty local git repository for a project. */
+  initWorkspace = async (projectId: string): Promise<string> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    await this.ensureDir(wsPath);
+
+    if (existsSync(join(wsPath, '.git'))) {
+      this.log('WORKSPACE', `Workspace already has a git repo: ${wsPath}`);
+      return wsPath;
+    }
+
+    this.log('WORKSPACE', `Initializing git repo at ${wsPath}`);
+    await this.claudeService.spawnCommand('git', ['init'], wsPath);
+
+    // Create an initial commit so branches and worktrees work
+    await this.claudeService.spawnCommand('git', ['commit', '--allow-empty', '-m', 'Initial commit'], wsPath);
+    this.log('WORKSPACE', `Git repo initialized at ${wsPath}`);
+    return wsPath;
+  };
+
+  /** Clone a remote repository into the project workspace. */
+  cloneRepo = async (projectId: string, cloneUrl: string): Promise<string> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    const parentDir = join(this.projectRoot, 'workspaces');
+    await this.ensureDir(parentDir);
+
+    // If workspace already exists, remove it first
+    if (existsSync(wsPath)) {
+      this.log('WORKSPACE', `Removing existing workspace before clone: ${wsPath}`);
+      await this.claudeService.spawnCommand('rm', ['-rf', wsPath], parentDir);
+    }
+
+    this.log('WORKSPACE', `Cloning ${cloneUrl} into ${wsPath}`);
+    await this.claudeService.spawnCommand('git', ['clone', cloneUrl, wsPath], parentDir);
+    this.log('WORKSPACE', `Clone completed for project ${projectId}`);
+    return wsPath;
+  };
+
+  /** Get the default branch name of the workspace repo. */
+  getDefaultBranch = async (projectId: string): Promise<string> => {
+    const wsPath = this.getWorkspacePath(projectId);
+
+    try {
+      // Try symbolic-ref for repos with a remote
+      const result = await this.claudeService.spawnCommand(
+        'git', ['symbolic-ref', 'refs/remotes/origin/HEAD', '--short'], wsPath,
+      );
+      // Returns e.g. "origin/main" — strip the "origin/" prefix
+      const branch = result.trim().replace(/^origin\//, '');
+      if (branch) return branch;
+    } catch {
+      // Fallback: try to get current branch name
+    }
+
+    try {
+      const result = await this.claudeService.spawnCommand('git', ['branch', '--show-current'], wsPath);
+      const branch = result.trim();
+      if (branch) return branch;
+    } catch {
+      // Final fallback
+    }
+
+    return 'main';
+  };
+
+  /** Pull latest changes from the remote on the default branch. */
+  pullLatest = async (projectId: string, token?: string, repoFullName?: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+
+    if (token && repoFullName) {
+      // Set up temporary credential for this pull
+      const authUrl = `https://x-access-token:${token}@github.com/${repoFullName}.git`;
+      await this.claudeService.spawnCommand('git', ['remote', 'set-url', 'origin', authUrl], wsPath);
+    }
+
+    try {
+      const branch = await this.getDefaultBranch(projectId);
+      this.log('WORKSPACE', `Pulling latest on ${branch} for project ${projectId}`);
+      await this.claudeService.spawnCommand('git', ['pull', 'origin', branch], wsPath);
+      this.log('WORKSPACE', `Pull completed for project ${projectId}`);
+    } catch (err: any) {
+      // Pull may fail if there's no remote or no upstream — that's OK for local-only repos
+      this.log('WORKSPACE', `Pull failed (non-fatal): ${err.message}`);
+    }
+
+    if (token && repoFullName) {
+      // Reset remote URL to non-authenticated form to avoid storing token
+      await this.claudeService.spawnCommand(
+        'git', ['remote', 'set-url', 'origin', `https://github.com/${repoFullName}.git`], wsPath,
+      ).catch(() => {});
+    }
+  };
+
+  /** Push the default branch to the remote. */
+  pushToRemote = async (projectId: string, token: string, repoFullName: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    const branch = await this.getDefaultBranch(projectId);
+
+    // Set authenticated remote URL temporarily
+    const authUrl = `https://x-access-token:${token}@github.com/${repoFullName}.git`;
+    await this.claudeService.spawnCommand('git', ['remote', 'set-url', 'origin', authUrl], wsPath);
+
+    try {
+      this.log('WORKSPACE', `Pushing ${branch} to remote for project ${projectId}`);
+      await this.claudeService.spawnCommand('git', ['push', 'origin', branch], wsPath);
+      this.log('WORKSPACE', `Push completed for project ${projectId}`);
+    } finally {
+      // Reset to non-authenticated URL
+      await this.claudeService.spawnCommand(
+        'git', ['remote', 'set-url', 'origin', `https://github.com/${repoFullName}.git`], wsPath,
+      ).catch(() => {});
+    }
+  };
+
+  /** Get workspace git status info. */
+  getStatus = async (projectId: string): Promise<{
+    hasWorkspace: boolean;
+    hasRemote: boolean;
+    currentBranch: string | null;
+    remoteUrl: string | null;
+  }> => {
+    const wsPath = this.getWorkspacePath(projectId);
+
+    if (!existsSync(join(wsPath, '.git'))) {
+      return { hasWorkspace: false, hasRemote: false, currentBranch: null, remoteUrl: null };
+    }
+
+    let currentBranch: string | null = null;
+    try {
+      const result = await this.claudeService.spawnCommand('git', ['branch', '--show-current'], wsPath);
+      currentBranch = result.trim() || null;
+    } catch {}
+
+    let remoteUrl: string | null = null;
+    let hasRemote = false;
+    try {
+      const result = await this.claudeService.spawnCommand('git', ['remote', 'get-url', 'origin'], wsPath);
+      remoteUrl = result.trim() || null;
+      hasRemote = !!remoteUrl;
+    } catch {}
+
+    return { hasWorkspace: true, hasRemote, currentBranch, remoteUrl };
+  };
+}

package/templates/assistkick-product-system/packages/backend/src/services/pty_session_manager.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, mock, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { PtySessionManager } from './pty_session_manager.ts';
+
+const createMockPty = () => {
+  const listeners: Record<string, Function> = {};
+  return {
+    onData: mock.fn((cb: Function) => { listeners.data = cb; }),
+    onExit: mock.fn((cb: Function) => { listeners.exit = cb; }),
+    write: mock.fn(),
+    resize: mock.fn(),
+    kill: mock.fn(),
+    _emit: (event: string, data: unknown) => listeners[event]?.(data),
+  };
+};
+
+describe('PtySessionManager', () => {
+  let manager: PtySessionManager;
+  let spawnMock: ReturnType<typeof mock.fn>;
+  let logMock: ReturnType<typeof mock.fn>;
+  let mockPty: ReturnType<typeof createMockPty>;
+  const PROJECT_ROOT = '/test/project/root';
+  const PROJECT_ID = 'proj_test';
+  const PROJECT_NAME = 'Test Project';
+
+  beforeEach(() => {
+    mockPty = createMockPty();
+    spawnMock = mock.fn(() => mockPty);
+    logMock = mock.fn();
+    manager = new PtySessionManager({ spawn: spawnMock as any, log: logMock, projectRoot: PROJECT_ROOT });
+  });
+
+  describe('spawnCommand uses projectRoot as cwd', () => {
+    it('passes projectRoot as cwd when auto-launching claude', () => {
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+
+      // Auto-launch is triggered on session creation
+      assert.equal(spawnMock.mock.calls.length, 1);
+      const spawnOptions = spawnMock.mock.calls[0].arguments[2] as Record<string, unknown>;
+      assert.equal(spawnOptions.cwd, PROJECT_ROOT);
+    });
+  });
+
+  describe('validateCommand', () => {
+    it('allows "claude" command', () => {
+      const result = manager.validateCommand('claude');
+      assert.equal(result.valid, true);
+    });
+
+    it('allows "claude" with arguments', () => {
+      const result = manager.validateCommand('claude --help');
+      assert.equal(result.valid, true);
+    });
+
+    it('rejects disallowed commands', () => {
+      const result = manager.validateCommand('rm -rf /');
+      assert.equal(result.valid, false);
+      assert.ok(result.error?.includes('not allowed'));
+    });
+
+    it('rejects empty command', () => {
+      const result = manager.validateCommand('');
+      assert.equal(result.valid, false);
+    });
+  });
+
+  describe('session lifecycle', () => {
+    it('creates a new named session with project binding', () => {
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      assert.equal(session.projectId, PROJECT_ID);
+      assert.equal(session.projectName, PROJECT_NAME);
+      assert.equal(session.state, 'running'); // auto-launch sets state to running
+      assert.ok(session.id.startsWith('term_'));
+      assert.ok(session.name.startsWith(PROJECT_NAME));
+    });
+
+    it('creates separate sessions for the same project', () => {
+      const s1 = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      const s2 = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      assert.notEqual(s1.id, s2.id);
+    });
+
+    it('destroys session and kills pty', () => {
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      // session.pty is already set by auto-launch
+      manager.destroySession(session.id);
+      assert.equal(mockPty.kill.mock.calls.length, 1);
+      assert.equal(manager.getSession(session.id), undefined);
+    });
+
+    it('lists all active sessions', () => {
+      const s1 = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      const s2 = manager.createSession('proj_other', 'Other', 80, 24);
+      const list = manager.listSessions();
+      assert.equal(list.length, 2);
+      assert.ok(list.some(s => s.id === s1.id));
+      assert.ok(list.some(s => s.id === s2.id));
+    });
+
+    it('session removed from list after destroy', () => {
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      manager.destroySession(session.id);
+      const list = manager.listSessions();
+      assert.equal(list.length, 0);
+    });
+  });
+
+  describe('auto-launch claude on session creation', () => {
+    it('auto-launches claude with --dangerously-skip-permissions and --append-system-prompt on session creation', () => {
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+
+      assert.equal(spawnMock.mock.calls.length, 1);
+      const [cmd, args] = spawnMock.mock.calls[0].arguments as [string, string[]];
+      assert.equal(cmd, 'claude');
+      assert.ok(args.includes('--dangerously-skip-permissions'));
+      assert.ok(args.includes('--append-system-prompt'));
+      assert.ok(args.includes(`We are working on project-id ${PROJECT_ID}`));
+    });
+
+    it('uses --append-system-prompt (not --system-prompt) to preserve default prompt', () => {
+      manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+
+      const [, args] = spawnMock.mock.calls[0].arguments as [string, string[]];
+      assert.ok(args.includes('--append-system-prompt'));
+      assert.ok(!args.includes('--system-prompt') || args.indexOf('--system-prompt') === args.indexOf('--append-system-prompt'));
+    });
+
+    it('includes the session projectId in the system prompt', () => {
+      const customProjectId = 'proj_custom_123';
+      manager.createSession(customProjectId, PROJECT_NAME, 80, 24);
+
+      const [, args] = spawnMock.mock.calls[0].arguments as [string, string[]];
+      const promptIndex = args.indexOf('--append-system-prompt');
+      assert.ok(promptIndex !== -1);
+      assert.ok(args[promptIndex + 1].includes(customProjectId));
+    });
+
+    it('does not re-launch claude when reconnecting to an existing session', () => {
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      // Reconnect is simulated by getSession — no new spawn
+      const existing = manager.getSession(session.id);
+      assert.ok(existing);
+      assert.equal(spawnMock.mock.calls.length, 1);
+    });
+
+    it('session state is running immediately after creation', () => {
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      assert.equal(session.state, 'running');
+    });
+  });
+
+  describe('formatSessionName', () => {
+    it('formats session name as ProjectName - DD/MM/YY - HH:MM', () => {
+      const date = new Date(2026, 2, 6, 14, 30); // 2026-03-06 14:30
+      const name = manager.formatSessionName('My Project', date);
+      assert.equal(name, 'My Project - 06/03/26 - 14:30');
+    });
+  });
+});