@angar2/taskery 0.8.1 → 1.0.1

package/bin/init.js

@@ -1,214 +1,123 @@
 #!/usr/bin/env node
-/**
- * bin/init.js
- * `npx @angar2/taskery init` 본체 — 현재 디렉토리에 template/ 자산 카피 + manifest 생성.
- *
- * 동작:
- *   1. cwd에 .taskery-manifest.json 이미 있으면 경고 + confirm
- *   2. template/ 안 *모든 파일* cwd로 카피 (디렉토리 자동 생성)
- *   3. *.local.md 사용자 오버라이드 충돌 검사 (덮어쓰지 X)
- *   4. .taskery-manifest.json 작성 (version + installed_at + files{path,hash,core,managed} 맵)
- *   5. 결과 요약 출력 + 다음 단계 안내 (`/project-init`)
- */
-
+// init — 리포 루트(또는 빈 폴더)에 taskery 1.0을 설치한다. 빈 폴더면 git 시작·빈 첫 커밋·부모 브랜치까지(§5-3)
 const fs = require('fs');
 const path = require('path');
-const readline = require('readline');
-
-const {
-  MANIFEST_NAME,
-  findTemplateDir,
-  walkTemplate,
-  copyFile,
-  writeManifest,
-  readManifest,
-  getPackageVersion,
-  isLocalOverride,
-  generateProjectId,
-  DEFAULT_STALE_DAYS,
-  DEFAULT_LOCK_TIMEOUT_MS,
-  resolveInstallPlan,
-  gitignorePatternsFor,
-} = require('./lib');
+const crypto = require('crypto');
+const L = require('./lib');
+const I = require('./install');
+
+async function selectPlatforms(asker) {
+  const ans = await asker.ask('에이전트 플랫폼 선택 — 1) Claude Code  2) Codex  3) 둘 다 (기본 1): ', '1');
+  if (ans === '2') return ['codex'];
+  if (ans === '3') return ['claude', 'codex'];
+  return ['claude'];
+}
 
-const { ENTRY_DOCS_MARKER } = require('./migrate');
+// 빈 폴더 — git 시작, exclude 등록, 빈 첫 커밋, 통합 브랜치 만들고 본진을 그 브랜치로
+function startGit(cwd) {
+  L.git(cwd, ['init', '-q']);
+  L.ensureExclude(cwd);
+  L.git(cwd, ['commit', '-q', '--allow-empty', '-m', 'chore: 첫 커밋']);
+  const branch = L.parseGitRuleTable(I.readTemplate('.taskery/rules/GIT_RULE.md')).integration || 'dev';
+  if (L.currentBranch(cwd) !== branch) L.git(cwd, ['checkout', '-q', '-b', branch]);
+  return branch;
+}
 
-async function confirm(msg) {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(`${msg} (y/N) `, (ans) => {
-      rl.close();
-      resolve(ans.trim().toLowerCase() === 'y');
-    });
-  });
+// 스택을 보고 빌드 결과 폴더를 제안한다 — 새 워크트리에 APFS 복제할 폴더(§7). Node는 npm ci라 등록하지 않는다
+function proposeBuildOutput(main) {
+  const found = [];
+  const dirs = ['', ...fs.readdirSync(main, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith('.')).map((d) => d.name)];
+  for (const d of dirs) {
+    if (fs.existsSync(path.join(main, d, 'Cargo.toml'))) {
+      found.push(path.posix.join(d, 'target'));
+      if (d === '') break; // 루트 워크스페이스면 target 하나
+    }
+  }
+  if (fs.existsSync(path.join(main, 'Package.swift'))) found.push('.build');
+  // Xcode 프로젝트 — 기본 DerivedData는 리포 밖·워크트리마다 다른 곳이라 리포 안 고정 경로로 쓴다
+  if (fs.readdirSync(main).some((n) => /\.(xcodeproj|xcworkspace)$/.test(n))) found.push('DerivedData');
+  return found;
 }
 
-// 에이전트 플랫폼 선택 — 고른 것만 독립 설치 (공통 .project/는 항상)
-async function selectPlatforms() {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(
-      `\n에이전트 플랫폼 선택:\n  1) Claude Code\n  2) Codex\n  3) 둘 다\n선택 (1/2/3, 기본 1): `,
-      (ans) => {
-        rl.close();
-        const c = ans.trim() || '1';
-        if (c === '2') resolve(['codex']);
-        else if (c === '3') resolve(['claude', 'codex']);
-        else resolve(['claude']);
-      },
+function checkRepo(cwd) {
+  if (!fs.existsSync(path.join(cwd, '.git')) && !L.gitOk(cwd, ['rev-parse', '--git-dir'])) {
+    L.fail('init: git이 없는 폴더에 파일이 이미 있다. 무엇을 첫 커밋에 넣을지(.env 같은 비밀값 포함 여부)는 사용자가 정할 일이라, `git init` 후 첫 커밋을 직접 만든 뒤 다시 부른다.');
+  }
+  if (!L.gitOk(cwd, ['rev-parse', '--verify', '-q', 'HEAD'])) {
+    L.fail('init: 커밋이 없는 리포다. 무엇을 첫 커밋에 넣을지는 사용자가 정할 일이라, 첫 커밋을 직접 만든 뒤 다시 부른다.');
+  }
+  if (L.findMain(cwd) !== fs.realpathSync(cwd)) {
+    L.fail(`init: 리포의 본진 루트에서 부른다 (본진: ${L.findMain(cwd)}).`);
+  }
+  const tracked = L.git(cwd, ['ls-files', '--', ...L.EXCLUDE_NAMES]);
+  if (tracked) {
+    const names = [...new Set(tracked.split('\n').map((f) => f.split('/')[0]))];
+    L.fail(
+      `init: git이 taskery 파일 이름을 이미 추적하고 있어 설치를 멈췄다: ${names.join(', ')}\n` +
+        'taskery 파일은 모두 git 밖에 둔다. 추적 해제는 리포 이력을 바꾸는 일이라 사용자가 한다 — ' +
+        '`git rm -r --cached <이름>`으로 추적을 해제해 커밋하거나 파일을 다른 곳으로 옮긴 뒤 다시 부른다.',
     );
-  });
+  }
 }
 
 async function main() {
   const cwd = process.cwd();
-  const templateDir = findTemplateDir();
-  const manifestPath = path.join(cwd, MANIFEST_NAME);
-
-  // 1. 기존 manifest 검사
-  if (fs.existsSync(manifestPath)) {
-    const ok = await confirm(
-      `${MANIFEST_NAME} 이미 존재 — taskery 이미 설치된 디렉토리. 'update' 사용 권장. 그래도 init 강행할까?`,
-    );
-    if (!ok) {
-      console.log('취소 — 종료.');
-      process.exit(0);
-    }
+  L.checkLegacyInstall(cwd, 'init');
+  if (fs.existsSync(path.join(cwd, L.MANIFEST_NAME))) {
+    L.fail('init: taskery가 이미 설치된 리포다. 갱신은 `npx @angar2/taskery update`.');
   }
-
-  // 2. 플랫폼 선택 + template/ 정독 → 설치 계획 전개 (공통 shared/는 플랫폼 경로로 매핑)
-  const platforms = await selectPlatforms();
-  const templateFiles = walkTemplate(templateDir);
-  const plan = resolveInstallPlan(templateFiles, platforms);
-
-  console.log(`\ntaskery v${getPackageVersion()} init`);
-  console.log(`대상: ${cwd}`);
-  console.log(`플랫폼: ${platforms.join(', ')}`);
-  console.log(`카피 대상: ${plan.length}개 파일\n`);
-
-  // 3. 카피 + manifest 빌드 (manifest 키 = 설치 경로 installRel)
-  const manifestFiles = {};
-  let copied = 0;
-  let skipped = 0;
-
-  for (const { templateRel, installRel, hash } of plan) {
-    const src = path.join(templateDir, templateRel);
-    const dst = path.join(cwd, installRel);
-
-    // .local.md suffix는 사용자 영역 — taskery template에는 없어야 정상이지만 방어적으로 스킵
-    if (isLocalOverride(installRel)) {
-      console.log(`  skip (.local override 영역): ${installRel}`);
-      skipped++;
-      continue;
-    }
-
-    // 사용자 .local.md 충돌 검사 — 사용자가 직접 만든 *.local.md 보호
-    // 본 init은 신규 설치 default, 충돌 거의 없지만 update 흐름과 일관성 유지
-    if (fs.existsSync(dst)) {
-      const ok = await confirm(`  '${installRel}' 이미 존재 — 덮어쓸까?`);
-      if (!ok) {
-        console.log(`    skip: ${installRel}`);
-        skipped++;
-        continue;
-      }
-    }
-
-    copyFile(src, dst);
-    manifestFiles[installRel] = { hash, core: true, managed: true };
-    copied++;
-    console.log(`  copy: ${installRel}`);
-  }
-
-  // 4. manifest 작성 — 멀티세션(0.1.2+): projectId / stale_days / lock_timeout_ms 포함
-  const manifest = {
-    version: getPackageVersion(),
-    installed_at: new Date().toISOString(),
-    projectId: generateProjectId(),
-    platforms,
-    stale_days: DEFAULT_STALE_DAYS,
-    lock_timeout_ms: DEFAULT_LOCK_TIMEOUT_MS,
-    activePlan: null, // /plan-init이 채운다 (0.7.0+ 활성 plan SSoT)
-    entryDocs: ENTRY_DOCS_MARKER, // 신규 설치는 이미 새 진입 문서 체계 — update가 이행을 시도하지 않도록
-    files: manifestFiles,
-  };
-  writeManifest(manifest, manifestPath);
-
-  // 4.5. .gitignore prompt (stash FRICTION_LOG #26 반영)
-  //   공개 repo면 내부 워크플로 파일 노출 회피 — taskery 내부 영역 .gitignore 등록 제안.
-  //   사용자 NO면 패스 (그대로 둠). 이미 등록되어 있으면 스킵.
-  const gitignorePath = path.join(cwd, '.gitignore');
-  const taskeryPatterns = gitignorePatternsFor(platforms);
-  const addGitignore = await confirm(
-    `\ntaskery 내부 파일(${taskeryPatterns.join(', ')})을 .gitignore에 등록할까?\n  (공개 repo면 권장 — 내부 워크플로 파일 노출 회피)`,
-  );
-  if (addGitignore) {
-    const existing = fs.existsSync(gitignorePath)
-      ? fs.readFileSync(gitignorePath, 'utf8').split('\n')
-      : [];
-    const existingSet = new Set(existing.map((l) => l.trim()));
-    const newPatterns = taskeryPatterns.filter((p) => !existingSet.has(p));
-    if (newPatterns.length > 0) {
-      const needsLeadingNewline =
-        existing.length > 0 && existing[existing.length - 1] !== '';
-      const block = [
-        needsLeadingNewline ? '' : null,
-        '# taskery 내부 파일',
-        ...newPatterns,
-        '',
-      ].filter((l) => l !== null);
-      fs.appendFileSync(gitignorePath, block.join('\n'));
-      console.log(`  .gitignore 갱신 — ${newPatterns.length}개 패턴 추가`);
-    } else {
-      console.log(`  .gitignore — taskery 패턴 이미 등록됨, 스킵`);
-    }
+  const notes = [];
+  if (fs.readdirSync(cwd).length === 0) {
+    const branch = startGit(cwd);
+    notes.push(`빈 폴더 — git을 시작하고 빈 첫 커밋을 만든 뒤 본진을 ${branch} 브랜치로 옮겼다`);
   } else {
-    console.log(`  .gitignore — 사용자 선택으로 패스`);
+    checkRepo(cwd);
   }
-
-  // 4.7. MCP 서버 등록 — Claude는 .mcp.json 생성(첫 세션 승인 게이트), Codex는 명령 안내.
-  //   MCP 도구 8종 = lib core의 구조화 입구(CLI와 동일 함수). 미등록 환경은 npx CLI가 폴백.
-  if (platforms.includes('claude')) {
-    const mcpJsonPath = path.join(cwd, '.mcp.json');
-    let mcpConfig = { mcpServers: {} };
-    if (fs.existsSync(mcpJsonPath)) {
-      // 기존 .mcp.json의 다른 서버 보존 — taskery 항목만 머지.
-      try {
-        mcpConfig = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf8'));
-      } catch (e) {
-        mcpConfig = { mcpServers: {} };
+  const main = L.findMain(cwd);
+  const asker = I.makeAsker();
+  try {
+    const platforms = await selectPlatforms(asker);
+    const files = {};
+    for (const it of I.installPlan(platforms)) {
+      const dst = path.join(main, it.dst);
+      if (fs.existsSync(dst)) {
+        if (it.kind === 'once') continue;
+        const ans = await asker.ask(`'${it.dst}'가 이미 있다 — 덮어쓸까? (y/N) `, 'n');
+        if (ans.toLowerCase() !== 'y') {
+          notes.push(`건너뜀: ${it.dst} (기존 파일 유지)`);
+          continue;
+        }
       }
-      if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+      const text = I.readTemplate(it.src);
+      I.writeFile(main, it.dst, text);
+      if (it.kind !== 'once') files[it.dst] = I.hashText(text);
     }
-    if (!mcpConfig.mcpServers.taskery) {
-      mcpConfig.mcpServers.taskery = { command: 'npx', args: ['-y', '@angar2/taskery', 'mcp'] };
-      fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2) + '\n');
-      console.log(`  .mcp.json — taskery MCP 서버 등록 (첫 세션에서 승인 필요)`);
-    } else {
-      console.log(`  .mcp.json — taskery 서버 이미 등록됨, 스킵`);
+    notes.push(...I.writeConfigs(main, platforms));
+    const buildOutput = proposeBuildOutput(main);
+    if (buildOutput.length) {
+      notes.push(`빌드 결과 폴더 등록: ${buildOutput.join(', ')} — 새 워크트리에 본진의 이 폴더를 APFS 복제한다(바꾸려면 .taskery/manifest.json의 buildOutput을 고친다)`);
+      if (buildOutput.includes('DerivedData')) notes.push('코드 테스트 명령에 -derivedDataPath DerivedData를 붙인다');
     }
+    const added = L.ensureExclude(main, buildOutput);
+    if (added.length) notes.push(`.git/info/exclude — ${added.join(' ')}`);
+    L.writeManifest(main, {
+      version: L.getPackageVersion(),
+      installed_at: new Date().toISOString(),
+      projectId: crypto.randomBytes(4).toString('hex'),
+      platforms,
+      files,
+      ...(buildOutput.length ? { buildOutput } : {}),
+    });
+    console.log(`taskery v${L.getPackageVersion()} 설치 완료 — ${main}`);
+    console.log(`- 플랫폼: ${platforms.join(', ')}`);
+    for (const n of notes) console.log(`- ${n}`);
+    console.log('다음: 에이전트 세션에서 project-init 스킬로 프로젝트 정보·용어집·코드 테스트 등록·첫 플랜을 만든다.');
+  } finally {
+    asker.close();
   }
-
-  // 5. 결과 보고
-  console.log(`\n✅ taskery init 완료`);
-  console.log(`   카피: ${copied}개 / 스킵: ${skipped}개`);
-  console.log(`   플랫폼: ${platforms.join(', ')}`);
-  console.log(`   manifest: ${MANIFEST_NAME}\n`);
-  console.log(`다음 단계:`);
-  let step = 1;
-  // 진입 문서 본문은 AGENTS.md 한 벌 — CLAUDE.md는 `@AGENTS.md` 임포트 한 줄이라 채울 것이 없다.
-  console.log(`  ${step++}. AGENTS.md 정독 + 프로젝트 메타 + 검증/테스트 명령 채우기`);
-  console.log(`     (.project/rules/TASKERY_RULE.md = taskery 사용 설명서 — 세션이 필독)`);
-  if (platforms.includes('claude')) {
-    console.log(`  ${step++}. Claude 첫 세션에서 taskery MCP 서버 승인 (.mcp.json — 구조화 도구 8종; 미승인 시 npx CLI 폴백)`);
-  }
-  if (platforms.includes('codex')) {
-    console.log(`  ${step++}. Codex 최초 1회 '/hooks'로 hook trust 승인 (.codex/config.toml — git-guard / closed-immutable)`);
-    console.log(`     + MCP 등록: codex mcp add taskery -- npx -y @angar2/taskery mcp`);
-  }
-  console.log(`  ${step++}. 에이전트 진입 → '/project-init' → '/plan-init <기능그룹>' → '/task-init'\n`);
 }
 
 main().catch((e) => {
-  console.error(`taskery init 실패: ${e.message}`);
+  console.error(e instanceof L.TaskeryError ? e.message : `taskery init 실패: ${e.stack || e.message}`);
   process.exit(1);
 });

package/bin/install.js

@@ -0,0 +1,143 @@
+// 설치·갱신이 함께 쓰는 도구 — 1.0이 설치하는 파일 목록, 설정 파일 병합, AGENTS.md 재조립, 질문 입력
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const readline = require('readline');
+const L = require('./lib');
+
+const TEMPLATE = path.resolve(__dirname, '..', 'template');
+const PLATFORMS = ['claude', 'codex'];
+// 1.0 스킬 10개(§5-1)
+const SKILLS = ['task-init', 'task-plan', 'task-dev', 'task-test', 'task-close', 'task-orche', 'project-init', 'plan-init', 'add-backlog', 'log-friction'];
+const RULES = ['TASKERY_RULE.md', 'GIT_RULE.md', 'TASK_DOC_RULE.md', 'CHANGELOG_RULE.md', 'MOCKUP_RULE.md'];
+// 리포가 소유하는 로컬 규칙 틀 — 없을 때만 만들고 update가 덮지 않는다(§6-2)
+const LOCAL_RULES = ['TEST_RULE.local.md', 'DEV_RULE.local.md'];
+const SKILL_ROOT = { claude: '.claude/skills', codex: '.codex/skills' };
+
+// kind: managed = 갱신 대상(사용자가 고쳤으면 묻는다) · agents = 프로젝트 절을 살려 재조립 · once = 없을 때만 만든다
+function installPlan(platforms, { agnostic = true } = {}) {
+  const plan = [];
+  if (agnostic) {
+    plan.push({ src: 'AGENTS.md', dst: 'AGENTS.md', kind: 'agents' });
+    for (const r of RULES) plan.push({ src: `.taskery/rules/${r}`, dst: `.taskery/rules/${r}`, kind: 'managed' });
+    for (const r of LOCAL_RULES) plan.push({ src: `.taskery/rules/${r}`, dst: `.taskery/rules/${r}`, kind: 'once' });
+    plan.push({ src: '.taskery/BACKLOG.md', dst: '.taskery/BACKLOG.md', kind: 'once' });
+  }
+  for (const p of platforms) {
+    if (p === 'claude') plan.push({ src: 'CLAUDE.md', dst: 'CLAUDE.md', kind: 'managed' });
+    for (const s of SKILLS) plan.push({ src: `shared/skills/${s}/SKILL.md`, dst: `${SKILL_ROOT[p]}/${s}/SKILL.md`, kind: 'managed' });
+  }
+  return plan;
+}
+
+function hashText(text) {
+  return 'sha256:' + crypto.createHash('sha256').update(text).digest('hex');
+}
+
+function readTemplate(rel) {
+  return fs.readFileSync(path.join(TEMPLATE, rel), 'utf8');
+}
+
+function writeFile(main, rel, text) {
+  const file = path.join(main, rel);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, text);
+}
+
+// AGENTS.md 재조립 — 새 문안에 기존 파일의 `## 프로젝트` 절(project-init이 채운 값)을 그대로 옮긴다
+function recomposeAgents(tpl, current) {
+  const grab = (text) => {
+    const m = text.match(/^## 프로젝트\n[\s\S]*?(?=^## |(?![\s\S]))/m);
+    return m ? m[0] : null;
+  };
+  const keep = current && grab(current);
+  const slot = grab(tpl);
+  return keep && slot ? tpl.replace(slot, keep) : tpl;
+}
+
+function readJson(file, fallback) {
+  if (!fs.existsSync(file)) return fallback;
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (e) {
+    L.fail(`${file}을 JSON으로 읽지 못했다 — 고친 뒤 다시 부른다.`);
+  }
+}
+
+// 플랫폼 설정 — Claude: 링크 너머 .taskery 쓰기 허용 + MCP 등록 / Codex: MCP 등록(자동 승인)
+function writeConfigs(main, platforms) {
+  const notes = [];
+  const mcpEntry = { command: 'npx', args: ['-y', '@angar2/taskery', 'mcp'] };
+  if (platforms.includes('claude')) {
+    const sFile = path.join(main, '.claude', 'settings.json');
+    const s = readJson(sFile, {});
+    s.permissions = s.permissions || {};
+    const dirs = s.permissions.additionalDirectories || [];
+    const want = path.join(main, '.taskery');
+    if (!dirs.includes(want)) {
+      s.permissions.additionalDirectories = [...dirs, want];
+      fs.mkdirSync(path.dirname(sFile), { recursive: true });
+      fs.writeFileSync(sFile, JSON.stringify(s, null, 2) + '\n');
+      notes.push('.claude/settings.json — 링크 너머 .taskery 쓰기 허용(additionalDirectories)');
+    }
+    const mFile = path.join(main, '.mcp.json');
+    const m = readJson(mFile, { mcpServers: {} });
+    m.mcpServers = m.mcpServers || {};
+    if (!m.mcpServers.taskery) {
+      m.mcpServers.taskery = mcpEntry;
+      fs.writeFileSync(mFile, JSON.stringify(m, null, 2) + '\n');
+      notes.push('.mcp.json — taskery MCP 서버 등록');
+    }
+  }
+  if (platforms.includes('codex')) {
+    const cFile = path.join(main, '.codex', 'config.toml');
+    const cur = fs.existsSync(cFile) ? fs.readFileSync(cFile, 'utf8') : '';
+    if (!/^\[mcp_servers\.taskery\]/m.test(cur)) {
+      const block = [
+        '[mcp_servers.taskery]',
+        'command = "npx"',
+        'args = ["-y", "@angar2/taskery", "mcp"]',
+        'default_tools_approval_mode = "approve"',
+        'tool_timeout_sec = 3600',
+        '',
+      ].join('\n');
+      fs.mkdirSync(path.dirname(cFile), { recursive: true });
+      fs.writeFileSync(cFile, cur ? `${cur.replace(/\s*$/, '')}\n\n${block}` : block);
+      notes.push('.codex/config.toml — taskery MCP 서버 등록(자동 승인 approve)');
+    }
+  }
+  return notes;
+}
+
+// 질문 입력 — 표준 입력의 줄을 차례로 받는다. 입력이 끝났으면 기본값을 쓴다
+function makeAsker() {
+  const queue = [];
+  const waiters = [];
+  let closed = false;
+  const rl = readline.createInterface({ input: process.stdin, terminal: false });
+  rl.on('line', (line) => (waiters.length ? waiters.shift()(line) : queue.push(line)));
+  rl.on('close', () => {
+    closed = true;
+    while (waiters.length) waiters.shift()(null);
+  });
+  return {
+    ask(question, def) {
+      process.stdout.write(question);
+      return new Promise((resolve) => {
+        const done = (line) => {
+          const v = line == null || line.trim() === '' ? def : line.trim();
+          if (line == null) process.stdout.write('\n');
+          resolve(v);
+        };
+        if (queue.length) done(queue.shift());
+        else if (closed) done(null);
+        else waiters.push(done);
+      });
+    },
+    close() {
+      rl.close();
+    },
+  };
+}
+
+module.exports = { TEMPLATE, PLATFORMS, SKILLS, installPlan, hashText, readTemplate, writeFile, recomposeAgents, writeConfigs, makeAsker };