tycono 0.1.42 → 0.1.43

package/src/api/src/services/git-save.ts

@@ -8,8 +8,16 @@
  * - SAVE_PATHS의 AKB 파일만 stage (유저 소스코드 미포함)
  * - git 없으면 graceful 비활성화
  * - remote 없으면 commit만 (push skip)
+ *
+ * Dual-Repo Support (DG-001):
+ * - repo='akb': AKB repo (COMPANY_ROOT), SAVE_PATHS 필터 적용
+ * - repo='code': Code repo (codeRoot), SAVE_PATHS 필터 비활성화
  */
 import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export type RepoType = 'akb' | 'code';
 
 export interface GitStatus {
   dirty: boolean;
@@ -63,6 +71,58 @@ const SAVE_PATHS = [
   'CLAUDE.md',
 ];
 
+interface TyconoConfig {
+  companyName: string;
+  engine: string;
+  createdAt: string;
+  codeRoot?: string;
+}
+
+/**
+ * Read codeRoot from .tycono/config.json
+ * @param akbRoot - AKB repository root (COMPANY_ROOT)
+ * @returns codeRoot path if configured, undefined otherwise
+ */
+function getCodeRoot(akbRoot: string): string | undefined {
+  try {
+    const configPath = join(akbRoot, '.tycono', 'config.json');
+    const content = readFileSync(configPath, 'utf-8');
+    const config: TyconoConfig = JSON.parse(content);
+    return config.codeRoot;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Resolve repository root based on repo type
+ * @param akbRoot - AKB repository root (COMPANY_ROOT)
+ * @param repo - Repository type ('akb' or 'code')
+ * @returns Resolved repository root path
+ * @throws Error if repo='code' but codeRoot not configured
+ */
+function resolveRepoRoot(akbRoot: string, repo: RepoType = 'akb'): string {
+  if (repo === 'akb') {
+    return akbRoot;
+  }
+
+  const codeRoot = getCodeRoot(akbRoot);
+  if (!codeRoot) {
+    throw new Error('codeRoot not configured in .tycono/config.json');
+  }
+
+  return codeRoot;
+}
+
+/**
+ * Check if SAVE_PATHS filter should be applied
+ * @param repo - Repository type
+ * @returns true if filter should be applied (AKB only)
+ */
+function shouldFilterPaths(repo: RepoType = 'akb'): boolean {
+  return repo === 'akb';
+}
+
 function run(cmd: string, cwd: string): string {
   try {
     return execSync(cmd, { cwd, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
@@ -80,24 +140,36 @@ function isGitRepo(root: string): boolean {
   return run('git rev-parse --is-inside-work-tree', root) === 'true';
 }
 
-/** Initialize a new git repository */
-export function gitInit(root: string): { ok: boolean; message: string } {
-  if (isGitRepo(root)) {
+/**
+ * Initialize a new git repository
+ * @param root - AKB repository root (COMPANY_ROOT)
+ * @param repo - Repository type ('akb' or 'code'), default 'akb'
+ */
+export function gitInit(root: string, repo: RepoType = 'akb'): { ok: boolean; message: string } {
+  const repoRoot = resolveRepoRoot(root, repo);
+
+  if (isGitRepo(repoRoot)) {
     return { ok: true, message: 'Already a git repository' };
   }
   try {
-    runOrThrow('git init', root);
-    runOrThrow('git add -A', root);
-    runOrThrow('git commit -m "Initial commit by Tycono"', root);
+    runOrThrow('git init', repoRoot);
+    runOrThrow('git add -A', repoRoot);
+    runOrThrow('git commit -m "Initial commit by Tycono"', repoRoot);
     return { ok: true, message: 'Git repository initialized with initial commit' };
   } catch (err) {
     return { ok: false, message: err instanceof Error ? err.message : 'git init failed' };
   }
 }
 
-/** Get current git status. Returns noGit=true if not a git repo. */
-export function getGitStatus(root: string): GitStatus {
-  if (!isGitRepo(root)) {
+/**
+ * Get current git status. Returns noGit=true if not a git repo.
+ * @param root - AKB repository root (COMPANY_ROOT)
+ * @param repo - Repository type ('akb' or 'code'), default 'akb'
+ */
+export function getGitStatus(root: string, repo: RepoType = 'akb'): GitStatus {
+  const repoRoot = resolveRepoRoot(root, repo);
+
+  if (!isGitRepo(repoRoot)) {
     return {
       dirty: false,
       modified: [],
@@ -110,17 +182,22 @@ export function getGitStatus(root: string): GitStatus {
     };
   }
 
-  const porcelain = run('git status --porcelain', root);
+  const porcelain = run('git status --porcelain', repoRoot);
   const lines = porcelain ? porcelain.split('\n').filter(Boolean) : [];
 
   const modified: string[] = [];
   const untracked: string[] = [];
+  const applyFilter = shouldFilterPaths(repo);
 
   for (const line of lines) {
     const status = line.substring(0, 2);
     const file = line.substring(3);
-    // Filter to save paths only — never include user source code
-    if (!SAVE_PATHS.some(p => file.startsWith(p))) continue;
+
+    // For CODE repo, include all files; for AKB, filter to SAVE_PATHS only
+    if (applyFilter && !SAVE_PATHS.some(p => file.startsWith(p))) {
+      continue;
+    }
+
     if (status.includes('?')) {
       untracked.push(file);
     } else {
@@ -129,19 +206,19 @@ export function getGitStatus(root: string): GitStatus {
   }
 
   let lastCommit: GitStatus['lastCommit'] = null;
-  const logLine = run('git log -1 --format=%H%n%s%n%aI', root);
+  const logLine = run('git log -1 --format=%H%n%s%n%aI', repoRoot);
   if (logLine) {
     const [sha, message, date] = logLine.split('\n');
     if (sha) lastCommit = { sha, message: message ?? '', date: date ?? '' };
   }
 
-  const branch = run('git rev-parse --abbrev-ref HEAD', root) || 'unknown';
-  const hasRemote = !!run('git remote', root);
+  const branch = run('git rev-parse --abbrev-ref HEAD', repoRoot) || 'unknown';
+  const hasRemote = !!run('git remote', repoRoot);
 
   let synced = true;
   if (hasRemote) {
-    const local = run('git rev-parse HEAD', root);
-    const remote = run(`git rev-parse origin/${branch}`, root);
+    const local = run('git rev-parse HEAD', repoRoot);
+    const remote = run(`git rev-parse origin/${branch}`, repoRoot);
     synced = !!local && local === remote;
   }
 
@@ -157,37 +234,44 @@ export function getGitStatus(root: string): GitStatus {
   };
 }
 
-/** Commit + push save-tracked files */
-export function gitSave(root: string, message?: string): SaveResult {
-  if (!isGitRepo(root)) {
+/**
+ * Commit + push save-tracked files
+ * @param root - AKB repository root (COMPANY_ROOT)
+ * @param message - Optional commit message
+ * @param repo - Repository type ('akb' or 'code'), default 'akb'
+ */
+export function gitSave(root: string, message?: string, repo: RepoType = 'akb'): SaveResult {
+  const repoRoot = resolveRepoRoot(root, repo);
+
+  if (!isGitRepo(repoRoot)) {
     throw new Error('Not a git repository. Run "git init" first.');
   }
 
-  const status = getGitStatus(root);
+  const status = getGitStatus(root, repo);
   if (!status.dirty) {
     throw new Error('No changes to save');
   }
 
   const allFiles = [...status.modified, ...status.untracked];
 
-  // Stage only save-tracked files
+  // Stage files
   for (const file of allFiles) {
-    runOrThrow(`git add "${file}"`, root);
+    runOrThrow(`git add "${file}"`, repoRoot);
   }
 
   const prefix = '[tycono] ';
   const commitMsg = message
     ? `${prefix}${message}`
     : `${prefix}Save — ${new Date().toISOString().slice(0, 16)} (${allFiles.length} files)`;
-  runOrThrow(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, root);
+  runOrThrow(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, repoRoot);
 
-  const sha = run('git rev-parse HEAD', root);
+  const sha = run('git rev-parse HEAD', repoRoot);
 
   let pushed = false;
   let pushError: string | undefined;
   if (status.hasRemote) {
     try {
-      runOrThrow(`git push origin ${status.branch}`, root);
+      runOrThrow(`git push origin ${status.branch}`, repoRoot);
       pushed = true;
     } catch (err) {
       pushError = err instanceof Error ? err.message : 'Push failed';
@@ -203,11 +287,18 @@ export function gitSave(root: string, message?: string): SaveResult {
   };
 }
 
-/** Get commit history */
-export function gitHistory(root: string, limit = 20): CommitInfo[] {
-  if (!isGitRepo(root)) return [];
+/**
+ * Get commit history
+ * @param root - AKB repository root (COMPANY_ROOT)
+ * @param limit - Maximum number of commits to retrieve
+ * @param repo - Repository type ('akb' or 'code'), default 'akb'
+ */
+export function gitHistory(root: string, limit = 20, repo: RepoType = 'akb'): CommitInfo[] {
+  const repoRoot = resolveRepoRoot(root, repo);
+
+  if (!isGitRepo(repoRoot)) return [];
 
-  const log = run(`git log --format=%H%n%h%n%s%n%aI -n ${limit}`, root);
+  const log = run(`git log --format=%H%n%h%n%s%n%aI -n ${limit}`, repoRoot);
   if (!log) return [];
 
   const lines = log.split('\n');
@@ -225,18 +316,28 @@ export function gitHistory(root: string, limit = 20): CommitInfo[] {
   return commits;
 }
 
-/** Restore files from a previous commit (non-destructive: creates new commit) */
-export function gitRestore(root: string, sha: string, paths?: string[]): RestoreResult {
-  if (!isGitRepo(root)) {
+/**
+ * Restore files from a previous commit (non-destructive: creates new commit)
+ * @param root - AKB repository root (COMPANY_ROOT)
+ * @param sha - Commit SHA to restore from
+ * @param paths - Optional paths to restore (defaults to SAVE_PATHS for AKB, all for CODE)
+ * @param repo - Repository type ('akb' or 'code'), default 'akb'
+ */
+export function gitRestore(root: string, sha: string, paths?: string[], repo: RepoType = 'akb'): RestoreResult {
+  const repoRoot = resolveRepoRoot(root, repo);
+
+  if (!isGitRepo(repoRoot)) {
     throw new Error('Not a git repository');
   }
 
-  const targetPaths = paths?.length ? paths : SAVE_PATHS;
+  // For CODE repo without explicit paths, restore everything (use '.')
+  // For AKB repo, use SAVE_PATHS
+  const targetPaths = paths?.length ? paths : (repo === 'code' ? ['.'] : SAVE_PATHS);
   const restoredFiles: string[] = [];
 
   for (const p of targetPaths) {
     try {
-      runOrThrow(`git checkout ${sha} -- "${p}"`, root);
+      runOrThrow(`git checkout ${sha} -- "${p}"`, repoRoot);
       restoredFiles.push(p);
     } catch {
       // Path may not exist in that commit — skip
@@ -248,10 +349,10 @@ export function gitRestore(root: string, sha: string, paths?: string[]): Restore
   }
 
   const msg = `[tycono] Restore from ${sha.slice(0, 7)} (${restoredFiles.length} paths)`;
-  runOrThrow('git add -A', root);
-  runOrThrow(`git commit -m "${msg}"`, root);
+  runOrThrow('git add -A', repoRoot);
+  runOrThrow(`git commit -m "${msg}"`, repoRoot);
 
-  const newSha = run('git rev-parse HEAD', root);
+  const newSha = run('git rev-parse HEAD', repoRoot);
 
   return { commitSha: newSha, restoredFiles };
 }