@assistkick/create 1.6.0 → 1.8.0

package/templates/assistkick-product-system/packages/backend/src/routes/files.ts

@@ -0,0 +1,356 @@
+/**
+ * File system routes — CRUD operations on project workspace files.
+ * GET    /api/projects/:id/files              — recursive directory tree
+ * GET    /api/projects/:id/files/content      — read file content
+ * PUT    /api/projects/:id/files/content      — write file content
+ * POST   /api/projects/:id/files              — create file or folder
+ * DELETE /api/projects/:id/files              — delete file or folder
+ * PATCH  /api/projects/:id/files              — rename/move file or folder
+ */
+
+import { Router } from 'express';
+import { resolve, join, extname, relative } from 'node:path';
+import { readdir, readFile, writeFile, mkdir, rm, rename, stat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import type { ProjectWorkspaceService } from '../services/project_workspace_service.js';
+
+interface FileRoutesDeps {
+  workspaceService: ProjectWorkspaceService;
+  log: (tag: string, ...args: any[]) => void;
+}
+
+interface TreeEntry {
+  name: string;
+  path: string;
+  type: 'file' | 'directory';
+  children?: TreeEntry[];
+}
+
+const BINARY_EXTENSIONS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.svg',
+  '.mp3', '.mp4', '.wav', '.ogg', '.webm', '.avi', '.mov',
+  '.pdf', '.zip', '.tar', '.gz', '.7z', '.rar',
+  '.woff', '.woff2', '.ttf', '.eot', '.otf',
+  '.exe', '.dll', '.so', '.dylib',
+  '.bin', '.dat', '.db', '.sqlite',
+]);
+
+const EXTENSION_LANGUAGE_MAP: Record<string, string> = {
+  '.ts': 'typescript',
+  '.tsx': 'typescript',
+  '.js': 'javascript',
+  '.jsx': 'javascript',
+  '.json': 'json',
+  '.html': 'html',
+  '.htm': 'html',
+  '.css': 'css',
+  '.scss': 'scss',
+  '.less': 'less',
+  '.md': 'markdown',
+  '.yaml': 'yaml',
+  '.yml': 'yaml',
+  '.xml': 'xml',
+  '.sql': 'sql',
+  '.sh': 'shell',
+  '.bash': 'shell',
+  '.zsh': 'shell',
+  '.py': 'python',
+  '.rb': 'ruby',
+  '.go': 'go',
+  '.rs': 'rust',
+  '.java': 'java',
+  '.c': 'c',
+  '.cpp': 'cpp',
+  '.h': 'c',
+  '.hpp': 'cpp',
+  '.cs': 'csharp',
+  '.php': 'php',
+  '.swift': 'swift',
+  '.kt': 'kotlin',
+  '.lua': 'lua',
+  '.r': 'r',
+  '.toml': 'toml',
+  '.ini': 'ini',
+  '.env': 'plaintext',
+  '.txt': 'plaintext',
+  '.log': 'plaintext',
+  '.gitignore': 'plaintext',
+  '.dockerignore': 'plaintext',
+  '.editorconfig': 'plaintext',
+  '.svg': 'xml',
+};
+
+const getLanguage = (filePath: string): string => {
+  const ext = extname(filePath).toLowerCase();
+  return EXTENSION_LANGUAGE_MAP[ext] || 'plaintext';
+};
+
+const isBinaryFile = (filePath: string): boolean => {
+  const ext = extname(filePath).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+};
+
+/**
+ * Validate that a path is safe — no traversal outside workspace.
+ * Returns the resolved absolute path if valid, or null if invalid.
+ */
+const resolveAndValidatePath = (workspacePath: string, relativePath: string): string | null => {
+  if (relativePath.includes('..')) {
+    return null;
+  }
+  const resolved = resolve(workspacePath, relativePath);
+  if (!resolved.startsWith(workspacePath)) {
+    return null;
+  }
+  return resolved;
+};
+
+/** Build a recursive directory tree. */
+const buildTree = async (dirPath: string, basePath: string): Promise<TreeEntry[]> => {
+  const entries = await readdir(dirPath, { withFileTypes: true });
+  const tree: TreeEntry[] = [];
+
+  for (const entry of entries) {
+    // Skip hidden files/directories (like .git)
+    if (entry.name.startsWith('.')) continue;
+
+    const fullPath = join(dirPath, entry.name);
+    const relPath = relative(basePath, fullPath);
+
+    if (entry.isDirectory()) {
+      const children = await buildTree(fullPath, basePath);
+      tree.push({ name: entry.name, path: relPath, type: 'directory', children });
+    } else {
+      tree.push({ name: entry.name, path: relPath, type: 'file' });
+    }
+  }
+
+  // Sort: directories first, then alphabetical
+  tree.sort((a, b) => {
+    if (a.type !== b.type) return a.type === 'directory' ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  return tree;
+};
+
+export const createFileRoutes = ({ workspaceService, log }: FileRoutesDeps): Router => {
+  const router: Router = Router({ mergeParams: true });
+
+  // GET / — recursive directory tree
+  router.get('/', async (req, res) => {
+    const { id } = req.params;
+    log('FILES', `GET /api/projects/${id}/files`);
+
+    try {
+      const wsPath = workspaceService.getWorkspacePath(id);
+      if (!existsSync(wsPath)) {
+        res.json({ tree: [] });
+        return;
+      }
+
+      const tree = await buildTree(wsPath, wsPath);
+      res.json({ tree });
+    } catch (err: any) {
+      log('FILES', `List files failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to list files: ${err.message}` });
+    }
+  });
+
+  // GET /content?path=relative/path — read file content
+  router.get('/content', async (req, res) => {
+    const { id } = req.params;
+    const filePath = req.query.path as string;
+    log('FILES', `GET /api/projects/${id}/files/content?path=${filePath}`);
+
+    if (!filePath) {
+      res.status(400).json({ error: 'path query parameter is required' });
+      return;
+    }
+
+    const wsPath = workspaceService.getWorkspacePath(id);
+    const resolved = resolveAndValidatePath(wsPath, filePath);
+    if (!resolved) {
+      res.status(400).json({ error: 'Invalid path' });
+      return;
+    }
+
+    try {
+      if (!existsSync(resolved)) {
+        res.status(404).json({ error: 'File not found' });
+        return;
+      }
+
+      const fileStat = await stat(resolved);
+      if (fileStat.isDirectory()) {
+        res.status(400).json({ error: 'Path is a directory, not a file' });
+        return;
+      }
+
+      if (isBinaryFile(resolved)) {
+        res.json({ binary: true, size: fileStat.size });
+        return;
+      }
+
+      const content = await readFile(resolved, 'utf-8');
+      const language = getLanguage(resolved);
+      res.json({ content, language });
+    } catch (err: any) {
+      log('FILES', `Read file failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to read file: ${err.message}` });
+    }
+  });
+
+  // PUT /content — write file content
+  router.put('/content', async (req, res) => {
+    const { id } = req.params;
+    const { path: filePath, content } = req.body;
+    log('FILES', `PUT /api/projects/${id}/files/content path="${filePath}"`);
+
+    if (!filePath || content === undefined) {
+      res.status(400).json({ error: 'path and content are required' });
+      return;
+    }
+
+    const wsPath = workspaceService.getWorkspacePath(id);
+    const resolved = resolveAndValidatePath(wsPath, filePath);
+    if (!resolved) {
+      res.status(400).json({ error: 'Invalid path' });
+      return;
+    }
+
+    try {
+      if (!existsSync(resolved)) {
+        res.status(404).json({ error: 'File not found' });
+        return;
+      }
+
+      await writeFile(resolved, content, 'utf-8');
+      res.json({ success: true });
+    } catch (err: any) {
+      log('FILES', `Write file failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to write file: ${err.message}` });
+    }
+  });
+
+  // POST / — create file or folder
+  router.post('/', async (req, res) => {
+    const { id } = req.params;
+    const { path: filePath, type } = req.body;
+    log('FILES', `POST /api/projects/${id}/files path="${filePath}" type="${type}"`);
+
+    if (!filePath || !type) {
+      res.status(400).json({ error: 'path and type are required' });
+      return;
+    }
+
+    if (type !== 'file' && type !== 'directory') {
+      res.status(400).json({ error: 'type must be "file" or "directory"' });
+      return;
+    }
+
+    const wsPath = workspaceService.getWorkspacePath(id);
+    const resolved = resolveAndValidatePath(wsPath, filePath);
+    if (!resolved) {
+      res.status(400).json({ error: 'Invalid path' });
+      return;
+    }
+
+    try {
+      if (existsSync(resolved)) {
+        res.status(400).json({ error: 'Path already exists' });
+        return;
+      }
+
+      if (type === 'directory') {
+        await mkdir(resolved, { recursive: true });
+      } else {
+        // Ensure parent directory exists
+        const parentDir = resolve(resolved, '..');
+        if (!existsSync(parentDir)) {
+          await mkdir(parentDir, { recursive: true });
+        }
+        await writeFile(resolved, '', 'utf-8');
+      }
+
+      res.json({ success: true });
+    } catch (err: any) {
+      log('FILES', `Create failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to create: ${err.message}` });
+    }
+  });
+
+  // DELETE /?path=relative/path — delete file or folder
+  router.delete('/', async (req, res) => {
+    const { id } = req.params;
+    const filePath = req.query.path as string;
+    log('FILES', `DELETE /api/projects/${id}/files?path=${filePath}`);
+
+    if (!filePath) {
+      res.status(400).json({ error: 'path query parameter is required' });
+      return;
+    }
+
+    const wsPath = workspaceService.getWorkspacePath(id);
+    const resolved = resolveAndValidatePath(wsPath, filePath);
+    if (!resolved) {
+      res.status(400).json({ error: 'Invalid path' });
+      return;
+    }
+
+    try {
+      if (!existsSync(resolved)) {
+        res.status(404).json({ error: 'File not found' });
+        return;
+      }
+
+      await rm(resolved, { recursive: true });
+      res.json({ success: true });
+    } catch (err: any) {
+      log('FILES', `Delete failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to delete: ${err.message}` });
+    }
+  });
+
+  // PATCH / — rename/move file or folder
+  router.patch('/', async (req, res) => {
+    const { id } = req.params;
+    const { oldPath, newPath } = req.body;
+    log('FILES', `PATCH /api/projects/${id}/files oldPath="${oldPath}" newPath="${newPath}"`);
+
+    if (!oldPath || !newPath) {
+      res.status(400).json({ error: 'oldPath and newPath are required' });
+      return;
+    }
+
+    const wsPath = workspaceService.getWorkspacePath(id);
+    const resolvedOld = resolveAndValidatePath(wsPath, oldPath);
+    const resolvedNew = resolveAndValidatePath(wsPath, newPath);
+
+    if (!resolvedOld || !resolvedNew) {
+      res.status(400).json({ error: 'Invalid path' });
+      return;
+    }
+
+    try {
+      if (!existsSync(resolvedOld)) {
+        res.status(404).json({ error: 'File not found' });
+        return;
+      }
+
+      // Ensure parent directory of new path exists
+      const newParentDir = resolve(resolvedNew, '..');
+      if (!existsSync(newParentDir)) {
+        await mkdir(newParentDir, { recursive: true });
+      }
+
+      await rename(resolvedOld, resolvedNew);
+      res.json({ success: true });
+    } catch (err: any) {
+      log('FILES', `Rename failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to rename: ${err.message}` });
+    }
+  });
+
+  return router;
+};

package/templates/assistkick-product-system/packages/backend/src/routes/git.ts

@@ -7,21 +7,25 @@
  * POST   /api/projects/:id/git/test           — test GitHub App connection
  * GET    /api/projects/:id/git/installations  — list GitHub App installations
  * GET    /api/projects/:id/git/repos          — list repos for an installation
+ * POST   /api/projects/:id/git/ssh/generate   — generate SSH keypair for project
+ * POST   /api/projects/:id/git/ssh/connect    — connect repo via SSH clone URL
  */
 
 import { Router } from 'express';
 import type { ProjectService } from '../services/project_service.js';
 import type { GitHubAppService } from '../services/github_app_service.js';
 import type { ProjectWorkspaceService } from '../services/project_workspace_service.js';
+import type { SshKeyService } from '../services/ssh_key_service.js';
 
 interface GitRoutesDeps {
   projectService: ProjectService;
   githubAppService: GitHubAppService;
   workspaceService: ProjectWorkspaceService;
+  sshKeyService: SshKeyService;
   log: (tag: string, ...args: any[]) => void;
 }
 
-export const createGitRoutes = ({ projectService, githubAppService, workspaceService, log }: GitRoutesDeps): Router => {
+export const createGitRoutes = ({ projectService, githubAppService, workspaceService, sshKeyService, log }: GitRoutesDeps): Router => {
   const router: Router = Router({ mergeParams: true });
 
   // POST /api/projects/:id/git/connect — connect a git repo
@@ -138,7 +142,10 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
         githubInstallationId: project.githubInstallationId,
         githubRepoFullName: project.githubRepoFullName,
         baseBranch: project.baseBranch,
+        gitAuthMethod: project.gitAuthMethod,
+        sshPublicKey: project.sshPublicKey,
         githubAppConfigured: githubAppService.isConfigured(),
+        sshConfigured: sshKeyService.isConfigured(),
       });
     } catch (err: any) {
       log('GIT', `Get git status failed: ${err.message}`);
@@ -227,5 +234,93 @@ export const createGitRoutes = ({ projectService, githubAppService, workspaceSer
     }
   });
 
+  // POST /api/projects/:id/git/ssh/generate — generate (or regenerate) SSH keypair
+  router.post('/ssh/generate', async (req, res) => {
+    const { id } = req.params;
+    log('GIT', `POST /api/projects/${id}/git/ssh/generate`);
+
+    try {
+      if (!sshKeyService.isConfigured()) {
+        res.status(400).json({ error: 'ENCRYPTION_KEY environment variable is not configured' });
+        return;
+      }
+
+      const project = await projectService.getById(id);
+      if (!project) {
+        res.status(404).json({ error: 'Project not found' });
+        return;
+      }
+
+      const keyPair = sshKeyService.generateKeyPair();
+      const encryptedPrivateKey = sshKeyService.encrypt(keyPair.privateKey);
+
+      const updated = await projectService.setSshKeys(id, {
+        sshPrivateKeyEncrypted: encryptedPrivateKey,
+        sshPublicKey: keyPair.publicKey,
+      });
+
+      res.json({
+        project: {
+          ...updated,
+          sshPrivateKeyEncrypted: undefined, // Never expose encrypted key to frontend
+        },
+        publicKey: keyPair.publicKey,
+      });
+    } catch (err: any) {
+      log('GIT', `Generate SSH key failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to generate SSH key: ${err.message}` });
+    }
+  });
+
+  // POST /api/projects/:id/git/ssh/connect — connect repo using SSH clone URL
+  router.post('/ssh/connect', async (req, res) => {
+    const { id } = req.params;
+    const { repoUrl, baseBranch } = req.body;
+    log('GIT', `POST /api/projects/${id}/git/ssh/connect repoUrl="${repoUrl}"`);
+
+    if (!repoUrl) {
+      res.status(400).json({ error: 'repoUrl is required (SSH clone URL, e.g. git@github.com:org/repo.git)' });
+      return;
+    }
+
+    try {
+      const project = await projectService.getById(id);
+      if (!project) {
+        res.status(404).json({ error: 'Project not found' });
+        return;
+      }
+
+      if (!project.sshPrivateKeyEncrypted) {
+        res.status(400).json({ error: 'No SSH key configured. Generate an SSH key first.' });
+        return;
+      }
+
+      // Clone using SSH
+      await workspaceService.cloneRepoSsh(id, repoUrl, project.sshPrivateKeyEncrypted);
+
+      // Detect default branch
+      const detectedBranch = await workspaceService.getDefaultBranch(id);
+      const effectiveBranch = baseBranch || detectedBranch;
+
+      // Save repo metadata
+      const updated = await projectService.connectRepo(id, {
+        repoUrl,
+        baseBranch: effectiveBranch,
+      });
+
+      res.json({
+        project: {
+          ...updated,
+          sshPrivateKeyEncrypted: undefined,
+          gitAuthMethod: project.gitAuthMethod,
+          sshPublicKey: project.sshPublicKey,
+        },
+      });
+    } catch (err: any) {
+      log('GIT', `SSH connect repo failed: ${err.message}`);
+      res.status(500).json({ error: `Failed to connect repo via SSH: ${err.message}` });
+    }
+  });
+
   return router;
 };

package/templates/assistkick-product-system/packages/backend/src/routes/graph.ts

@@ -49,6 +49,7 @@ router.get('/node/:id', async (req, res) => {
                 status: row.status,
                 priority: row.priority,
                 ...(row.kind ? {kind: row.kind} : {}),
+                ...(row.featureType ? {feature_type: row.featureType} : {}),
                 created_at: row.createdAt,
                 updated_at: row.updatedAt,
             };

package/templates/assistkick-product-system/packages/backend/src/routes/kanban.ts

@@ -1,12 +1,12 @@
 /**
- * Kanban API routes — CRUD for kanban board, notes, pipeline.
+ * Kanban API routes — CRUD for kanban board, notes.
  */
 
 import { Router } from 'express';
 import { randomUUID } from 'node:crypto';
 import { readGraph } from '@assistkick/shared/lib/graph.js';
 import { loadKanban, getKanbanEntry, saveKanbanEntry } from '@assistkick/shared/lib/kanban.js';
-import { log, pipeline } from '../services/init.js';
+import { log } from '../services/init.js';
 
 const router: Router = Router();
 
@@ -19,9 +19,9 @@ router.get('/', async (req, res) => {
   try {
     const kanban = await loadKanban(projectId);
 
-    // Auto-add missing feature nodes to the Backlog column
+    // Auto-add missing feature and epic nodes to the Backlog column
     const graph = await readGraph(projectId);
-    const featureNodes = graph.nodes.filter((n: any) => n.type === 'feature');
+    const featureNodes = graph.nodes.filter((n: any) => n.type === 'feature' || n.type === 'epic');
     for (const node of featureNodes) {
       if (!kanban[node.id]) {
         const newEntry = {
@@ -36,6 +36,22 @@ router.get('/', async (req, res) => {
       }
     }
 
+    // Enrich kanban entries with epic_parent_id from contains edges
+    const childToEpic = new Map<string, string>();
+    for (const edge of graph.edges) {
+      if (edge.relation !== 'contains') continue;
+      const parentNode = graph.nodes.find((n: any) => n.id === edge.from);
+      if (parentNode?.type === 'epic') {
+        childToEpic.set(edge.to, edge.from);
+      }
+    }
+    for (const [nodeId, entry] of Object.entries(kanban) as [string, any][]) {
+      const epicParentId = childToEpic.get(nodeId);
+      if (epicParentId) {
+        entry.epic_parent_id = epicParentId;
+      }
+    }
+
     res.json(kanban);
   } catch (err: any) {
     log('API', `GET /api/kanban FAILED: ${err.message}`);
@@ -88,11 +104,34 @@ router.post('/:id/move', async (req, res) => {
     await saveKanbanEntry(featureId, entry);
     log('MOVE', `OK: ${featureId} ${currentColumn} → ${column}`);
 
+    // If this is an epic, cascade move to all child features
+    const movedChildren: string[] = [];
+    const projectId = req.query.project_id as string | undefined;
+    const graph = await readGraph(projectId);
+    const node = graph.nodes.find((n: any) => n.id === featureId);
+    if (node?.type === 'epic') {
+      const childIds = graph.edges
+        .filter((e: any) => e.from === featureId && e.relation === 'contains')
+        .map((e: any) => e.to);
+      for (const childId of childIds) {
+        const childEntry = await getKanbanEntry(childId);
+        if (childEntry && childEntry.column !== column) {
+          const childPrev = childEntry.column;
+          childEntry.column = column;
+          childEntry.moved_at = new Date().toISOString();
+          await saveKanbanEntry(childId, childEntry);
+          movedChildren.push(childId);
+          log('MOVE', `CASCADE: ${childId} ${childPrev} → ${column} (child of ${featureId})`);
+        }
+      }
+    }
+
     res.json({
       feature_id: featureId,
       previous_column: currentColumn,
       new_column: column,
       rejection_count: entry.rejection_count || 0,
+      moved_children: movedChildren,
     });
   } catch (err: any) {
     log('MOVE', `ERROR: ${err.message}`);