tycono-server 0.1.0-beta.0

package/src/api/src/routes/git.ts

@@ -0,0 +1,211 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { execSync } from 'node:child_process';
+import { COMPANY_ROOT } from '../services/file-reader.js';
+import { resolveCodeRoot } from '../services/company-config.js';
+
+export const gitRouter = Router();
+
+type RepoType = 'akb' | 'code';
+
+interface WorktreeInfo {
+  path: string;
+  branch: string;
+  commitHash: string;
+  isMain: boolean;
+}
+
+interface LastCommit {
+  hash: string;
+  message: string;
+  date: string;
+}
+
+/**
+ * Resolve repository root based on repo type
+ */
+function resolveRepoRoot(repo: RepoType = 'akb'): string {
+  if (repo === 'akb') {
+    return COMPANY_ROOT;
+  }
+  return resolveCodeRoot(COMPANY_ROOT);
+}
+
+function git(cmd: string, cwd: string): string {
+  return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 5000 }).trim();
+}
+
+// GET /api/git/status?repo=akb|code
+gitRouter.get('/status', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const repoParam = (req.query.repo as string) ?? 'akb';
+    const repo: RepoType = repoParam === 'code' ? 'code' : 'akb';
+
+    let repoRoot: string;
+    try {
+      repoRoot = resolveRepoRoot(repo);
+    } catch (err) {
+      res.status(400).json({
+        error: repo === 'code'
+          ? 'Code root not configured or inaccessible'
+          : 'Company root not found'
+      });
+      return;
+    }
+
+    // Current branch
+    let currentBranch: string;
+    try {
+      currentBranch = git('rev-parse --abbrev-ref HEAD', repoRoot);
+    } catch {
+      res.status(500).json({ error: 'Not a git repository or git is not available' });
+      return;
+    }
+
+    // Worktrees
+    let worktrees: WorktreeInfo[] = [];
+    try {
+      const raw = git('worktree list --porcelain', repoRoot);
+      const blocks = raw.split('\n\n').filter(Boolean);
+      for (const block of blocks) {
+        const lines = block.split('\n');
+        const wtPath = lines.find(l => l.startsWith('worktree '))?.replace('worktree ', '') ?? '';
+        const commitHash = lines.find(l => l.startsWith('HEAD '))?.replace('HEAD ', '') ?? '';
+        const branchLine = lines.find(l => l.startsWith('branch '));
+        const branch = branchLine ? branchLine.replace('branch refs/heads/', '') : '(detached)';
+        const isMain = lines.some(l => l === 'worktree ' + repoRoot) ||
+          (!branchLine && lines.some(l => l === 'bare'));
+        worktrees.push({
+          path: wtPath,
+          branch,
+          commitHash,
+          isMain: wtPath === repoRoot,
+        });
+      }
+    } catch {
+      worktrees = [];
+    }
+
+    // Stale (unmerged) branches
+    let staleBranches: string[] = [];
+    try {
+      const raw = git('branch --no-merged develop', repoRoot);
+      staleBranches = raw
+        .split('\n')
+        .map(b => b.trim().replace(/^\*\s*/, ''))
+        .filter(Boolean);
+    } catch {
+      staleBranches = [];
+    }
+
+    // Unsaved changes count
+    let unsavedChanges = 0;
+    try {
+      const raw = git('status --porcelain', repoRoot);
+      unsavedChanges = raw ? raw.split('\n').filter(Boolean).length : 0;
+    } catch {
+      unsavedChanges = 0;
+    }
+
+    // Last commit
+    let lastCommit: LastCommit | null = null;
+    try {
+      const raw = git('log -1 --format=%H%n%s%n%aI', repoRoot);
+      const [hash, message, date] = raw.split('\n');
+      if (hash) {
+        lastCommit = { hash, message: message ?? '', date: date ?? '' };
+      }
+    } catch {
+      lastCommit = null;
+    }
+
+    res.json({
+      currentBranch,
+      worktrees,
+      staleBranches,
+      unsavedChanges,
+      lastCommit,
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// DELETE /api/git/worktree/:path — Remove a worktree
+gitRouter.delete('/worktree/{*path}', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const rawPath = (req.params as Record<string, unknown>).path;
+    const worktreePath = Array.isArray(rawPath) ? rawPath.join('/') : String(rawPath ?? '');
+    if (!worktreePath) {
+      res.status(400).json({ error: 'Worktree path is required' });
+      return;
+    }
+
+    try {
+      const repoRoot = resolveRepoRoot('code');
+      git(`worktree remove ${JSON.stringify(worktreePath)}`, repoRoot);
+    } catch {
+      // Try force remove if normal remove fails
+      const repoRoot = resolveRepoRoot('code');
+      git(`worktree remove --force ${JSON.stringify(worktreePath)}`, repoRoot);
+    }
+
+    res.json({ success: true, removed: worktreePath });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Failed to remove worktree';
+    res.status(500).json({ error: message });
+  }
+});
+
+// DELETE /api/git/branch/:name — Delete a branch (local + remote)
+gitRouter.delete('/branch/{*name}', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const rawName = (req.params as Record<string, unknown>).name;
+    const branchName = Array.isArray(rawName) ? rawName.join('/') : String(rawName ?? '');
+    if (!branchName) {
+      res.status(400).json({ error: 'Branch name is required' });
+      return;
+    }
+
+    // Prevent deleting main/develop
+    if (branchName === 'main' || branchName === 'develop') {
+      res.status(403).json({ error: `Cannot delete protected branch: ${branchName}` });
+      return;
+    }
+
+    const errors: string[] = [];
+
+    // Delete local branch
+    try {
+      const repoRoot = resolveRepoRoot('code');
+      git(`branch -d ${JSON.stringify(branchName)}`, repoRoot);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'Unknown error';
+      // If branch is not fully merged, report but continue to try remote
+      if (msg.includes('not fully merged')) {
+        errors.push(`Local branch not fully merged. Use force delete if intended.`);
+      } else if (!msg.includes('not found')) {
+        errors.push(`Local: ${msg}`);
+      }
+    }
+
+    // Delete remote branch
+    try {
+      const repoRoot = resolveRepoRoot('code');
+      git(`push origin --delete ${JSON.stringify(branchName)}`, repoRoot);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'Unknown error';
+      if (!msg.includes('remote ref does not exist')) {
+        errors.push(`Remote: ${msg}`);
+      }
+    }
+
+    if (errors.length > 0) {
+      res.status(207).json({ success: false, branch: branchName, errors });
+    } else {
+      res.json({ success: true, deleted: branchName });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Failed to delete branch';
+    res.status(500).json({ error: message });
+  }
+});

package/src/api/src/routes/knowledge.ts

@@ -0,0 +1,378 @@
+/**
+ * knowledge.ts — Knowledge Base API routes
+ *
+ * GET /api/knowledge     — 전체 문서 목록 (frontmatter, TL;DR, cross-links)
+ * GET /api/knowledge/*   — 단일 문서 (full content, wildcard nested path)
+ */
+import { Router, Request, Response, NextFunction } from 'express';
+import fs from 'node:fs';
+import path from 'node:path';
+import matter from 'gray-matter';
+import { glob } from 'glob';
+import { COMPANY_ROOT } from '../services/file-reader.js';
+import { detectDecay, searchRelatedDocs, extractKeywords } from '../engine/knowledge-gate.js';
+
+export const knowledgeRouter = Router();
+
+function knowledgeDir(): string { return path.join(COMPANY_ROOT, 'knowledge'); }
+function companyRoot(): string { return COMPANY_ROOT; }
+
+/* ─── Helpers ─────────────────────────────────────── */
+
+function extractTldr(content: string): string {
+  // Try > blockquote on the first few lines
+  const blockquoteMatch = content.match(/^>\s+(.+)/m);
+  if (blockquoteMatch) return blockquoteMatch[1].trim().slice(0, 160);
+
+  // Try ## TL;DR section
+  const tldrSection = content.match(/##\s+TL;DR\s*\n+([^\n#]+)/i);
+  if (tldrSection) return tldrSection[1].trim().slice(0, 160);
+
+  // Fallback: first non-heading, non-empty line
+  const firstLine = content
+    .split('\n')
+    .find((l) => l.trim().length > 0 && !l.startsWith('#') && !l.startsWith('---') && !l.startsWith('|'));
+  return firstLine?.trim().slice(0, 160) ?? '';
+}
+
+function extractLinks(content: string): { text: string; href: string }[] {
+  const matches = [...content.matchAll(/\[([^\]]+)\]\(([^)]+\.md[^)]*)\)/g)];
+  return matches.map((m) => ({ text: m[1], href: m[2] })).slice(0, 20);
+}
+
+function inferCategory(filePath: string, tags: string[]): string {
+  // dir name as category
+  const parts = filePath.split('/');
+  if (parts.length > 1) return parts[0];
+
+  // domain/ tag
+  const domainTag = tags.find((t) => t.startsWith('domain/'));
+  if (domainTag) return domainTag.replace('domain/', '');
+
+  // keyword fallback from remaining tags
+  const knownCategories = ['tech', 'market', 'strategy', 'financial', 'process', 'competitor'];
+  for (const tag of tags) {
+    if (knownCategories.includes(tag)) return tag;
+  }
+
+  return 'general';
+}
+
+/* ─── List endpoint ───────────────────────────────── */
+
+knowledgeRouter.get('/', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    if (!fs.existsSync(companyRoot())) {
+      res.json([]);
+      return;
+    }
+
+    const files = glob.sync('**/*.{md,html}', {
+      cwd: companyRoot(),
+      ignore: [
+        'node_modules/**', '.claude/**', '.obsidian/**', '.tycono/**', '.git/**',
+        '**/node_modules/**',
+      ],
+    })
+      .filter((f) => {
+        const base = path.basename(f);
+        // Exclude hub files (folder-name.md pattern) and CLAUDE.md
+        if (base === 'CLAUDE.md') return false;
+        return true;
+      })
+      .sort();
+
+    const docs = files.map((f) => {
+      const absPath = path.join(companyRoot(), f);
+      let raw = '';
+      try { raw = fs.readFileSync(absPath, 'utf-8'); } catch { return null; }
+
+      const isHtml = f.endsWith('.html');
+      const format: 'md' | 'html' = isHtml ? 'html' : 'md';
+
+      if (isHtml) {
+        // HTML files: extract <title>, no frontmatter
+        const titleMatch = raw.match(/<title>([^<]+)<\/title>/i);
+        const title = titleMatch ? titleMatch[1].trim() : path.basename(f, '.html');
+        const category = inferCategory(f, []);
+        return {
+          id: f.replace(/\\/g, '/'),
+          title,
+          akb_type: 'node' as const,
+          status: 'active' as const,
+          tags: [] as string[],
+          category,
+          tldr: '',
+          links: [] as { text: string; href: string }[],
+          format,
+        };
+      }
+
+      const { data, content } = matter(raw);
+
+      const tags: string[] = Array.isArray(data.tags) ? data.tags : [];
+      const akbType: 'hub' | 'node' = data.akb_type === 'hub' ? 'hub' : 'node';
+      const status: 'active' | 'draft' | 'deprecated' =
+        data.status === 'draft' ? 'draft' : data.status === 'deprecated' ? 'deprecated' : 'active';
+
+      // Title: frontmatter > first # heading > filename
+      let title: string = (data.title as string) ?? '';
+      if (!title) {
+        const headingMatch = content.match(/^#\s+(.+)/m);
+        title = headingMatch ? headingMatch[1].trim() : path.basename(f, '.md');
+      }
+
+      const category = inferCategory(f, tags);
+      const tldr = extractTldr(content);
+      const links = extractLinks(content);
+
+      return {
+        id: f.replace(/\\/g, '/'),
+        title,
+        akb_type: akbType,
+        status,
+        tags,
+        category,
+        tldr,
+        links,
+        format,
+      };
+    }).filter(Boolean);
+
+    res.json(docs);
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── Knowledge Health endpoint ──────────────────── */
+
+knowledgeRouter.get('/health', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const report = detectDecay(companyRoot());
+    res.json(report);
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── Related docs search endpoint ──────────────── */
+
+knowledgeRouter.get('/related', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const query = String(req.query.q ?? '');
+    if (!query) {
+      res.status(400).json({ error: 'q parameter required' });
+      return;
+    }
+
+    const keywords = extractKeywords(query);
+    const docs = searchRelatedDocs(companyRoot(), keywords);
+    res.json({ keywords, docs });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── Single document endpoint ────────────────────── */
+
+/* ─── Create document endpoint ───────────────────── */
+
+knowledgeRouter.post('/', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { filename, title, category, content } = req.body as {
+      filename?: string;
+      title?: string;
+      category?: string;
+      content?: string;
+    };
+
+    if (!filename || !title) {
+      res.status(400).json({ error: 'filename and title required' });
+      return;
+    }
+
+    // Sanitize filename
+    const safeName = filename.replace(/[^a-zA-Z0-9가-힣_\-. ]/g, '').replace(/\s+/g, '-');
+    const fullName = safeName.endsWith('.md') ? safeName : `${safeName}.md`;
+    const absPath = path.join(knowledgeDir(), fullName);
+
+    if (!absPath.startsWith(knowledgeDir())) {
+      res.status(403).json({ error: 'Forbidden' });
+      return;
+    }
+
+    if (fs.existsSync(absPath)) {
+      res.status(409).json({ error: 'Document already exists' });
+      return;
+    }
+
+    // Build file with frontmatter
+    const frontmatter = {
+      title,
+      status: 'draft',
+      akb_type: 'node',
+      tags: category ? [category] : [],
+    };
+
+    const fileContent = matter.stringify(content || `# ${title}\n`, frontmatter);
+    fs.mkdirSync(path.dirname(absPath), { recursive: true });
+    fs.writeFileSync(absPath, fileContent);
+
+    res.status(201).json({ id: fullName, title });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── Update document endpoint ───────────────────── */
+
+knowledgeRouter.put('/{*path}', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const rawPath = (req.params as Record<string, unknown>).path;
+    const docId = Array.isArray(rawPath) ? rawPath.join('/') : String(rawPath ?? '');
+    if (!docId) {
+      res.status(400).json({ error: 'Document ID required' });
+      return;
+    }
+
+    const absPath = path.resolve(companyRoot(), docId);
+    if (!absPath.startsWith(companyRoot() + path.sep) && absPath !== companyRoot()) {
+      res.status(403).json({ error: 'Forbidden' });
+      return;
+    }
+
+    if (!fs.existsSync(absPath)) {
+      res.status(404).json({ error: `Document not found: ${docId}` });
+      return;
+    }
+
+    const { content } = req.body as { content?: string };
+    if (content === undefined) {
+      res.status(400).json({ error: 'content required' });
+      return;
+    }
+
+    // Read existing frontmatter
+    const raw = fs.readFileSync(absPath, 'utf-8');
+    const { data } = matter(raw);
+
+    // Preserve frontmatter, update content
+    const updated = matter.stringify(content, data);
+    fs.writeFileSync(absPath, updated);
+
+    res.json({ id: docId, status: 'updated' });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── Delete document endpoint ───────────────────── */
+
+knowledgeRouter.delete('/{*path}', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const rawPath = (req.params as Record<string, unknown>).path;
+    const docId = Array.isArray(rawPath) ? rawPath.join('/') : String(rawPath ?? '');
+    if (!docId) {
+      res.status(400).json({ error: 'Document ID required' });
+      return;
+    }
+
+    const absPath = path.resolve(companyRoot(), docId);
+    if (!absPath.startsWith(companyRoot() + path.sep) && absPath !== companyRoot()) {
+      res.status(403).json({ error: 'Forbidden' });
+      return;
+    }
+
+    if (!fs.existsSync(absPath)) {
+      res.status(404).json({ error: `Document not found: ${docId}` });
+      return;
+    }
+
+    fs.unlinkSync(absPath);
+    res.json({ id: docId, status: 'deleted' });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── Single document endpoint ────────────────────── */
+
+knowledgeRouter.get('/{*path}', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const rawPath = (req.params as Record<string, unknown>).path;
+    const docId = Array.isArray(rawPath) ? rawPath.join('/') : String(rawPath ?? '');
+    if (!docId) {
+      res.status(400).json({ error: 'Document ID required' });
+      return;
+    }
+
+    const absPath = path.resolve(companyRoot(), docId);
+
+    // Security: ensure path stays within companyRoot
+    if (!absPath.startsWith(companyRoot() + path.sep) && absPath !== companyRoot()) {
+      res.status(403).json({ error: 'Forbidden' });
+      return;
+    }
+
+    if (!fs.existsSync(absPath)) {
+      res.status(404).json({ error: `Document not found: ${docId}` });
+      return;
+    }
+
+    const raw = fs.readFileSync(absPath, 'utf-8');
+    const isHtml = docId.endsWith('.html');
+    const format: 'md' | 'html' = isHtml ? 'html' : 'md';
+
+    if (isHtml) {
+      const titleMatch = raw.match(/<title>([^<]+)<\/title>/i);
+      const title = titleMatch ? titleMatch[1].trim() : path.basename(docId, '.html');
+      const category = inferCategory(docId, []);
+      res.json({
+        id: docId,
+        title,
+        akb_type: 'node',
+        status: 'active',
+        tags: [],
+        category,
+        tldr: '',
+        links: [],
+        content: raw,
+        format,
+      });
+      return;
+    }
+
+    const { data, content } = matter(raw);
+
+    const tags: string[] = Array.isArray(data.tags) ? data.tags : [];
+    const akbType: 'hub' | 'node' = data.akb_type === 'hub' ? 'hub' : 'node';
+    const status: 'active' | 'draft' | 'deprecated' =
+      data.status === 'draft' ? 'draft' : data.status === 'deprecated' ? 'deprecated' : 'active';
+
+    let title: string = (data.title as string) ?? '';
+    if (!title) {
+      const headingMatch = content.match(/^#\s+(.+)/m);
+      title = headingMatch ? headingMatch[1].trim() : path.basename(docId, '.md');
+    }
+
+    const category = inferCategory(docId, tags);
+    const tldr = extractTldr(content);
+    const links = extractLinks(content);
+
+    res.json({
+      id: docId,
+      title,
+      akb_type: akbType,
+      status,
+      tags,
+      category,
+      tldr,
+      links,
+      content,
+      format,
+    });
+  } catch (err) {
+    next(err);
+  }
+});