@angar2/taskery 0.8.1 → 1.0.1

package/bin/check.js

@@ -0,0 +1,182 @@
+// approve-plan · test-code · test-scenario — 계획 끝 기록, 코드 테스트, 실사용 시나리오 결과(§5-3)
+const L = require('./lib');
+
+async function approvePlan(ctx, a) {
+  const main = ctx.main;
+  const num = L.parseTaskNum(a.task);
+  const st = L.readState(main, num);
+  if (st.closed) L.fail(`${L.taskLabel(num)}은 이미 닫혔다.`);
+  const text = L.readDoc(main, st);
+  const problems = [];
+  const newDoc = L.isNewDoc(text);
+  const goal = L.goalProblem(text);
+  if (goal) problems.push(goal);
+  const files = L.plannedFiles(text);
+  if (L.sw(st, 'dev') && !files.length) {
+    problems.push(
+      newDoc
+        ? '`## 개발 계획`에 파일이 없다 — small은 한 줄에 `- 경로` 하나, medium·large는 Phase마다 `- 파일:`'
+        : '`## 만질 파일`(medium·large는 `## Phase`의 `- 파일:` 포함)에 파일이 없다 — 한 줄에 `- 경로` 하나씩',
+    );
+  }
+  if (L.sw(st, 'test')) {
+    const n = L.parseCriteria(text).length;
+    if (n < 1 || n > 5) {
+      problems.push(`\`## ${newDoc ? '테스트 계획' : '완료 기준'}\` 완료 기준이 ${n}개다 — 테스트 켜짐이면 1~5개를 \`1. [AUTO] 시작 → 행동 → 기대하는 끝 상태\` 형식으로 적는다`);
+    }
+  }
+  if (problems.length) L.fail(`approve-plan: ${L.taskLabel(num)} 태스크 문서를 고친 뒤 다시 부른다.\n${problems.map((p) => `- ${p}`).join('\n')}\n문서: ${L.docShown(main, st)}`);
+  st.approve = { at: L.nowIso(), files };
+  L.writeState(main, st);
+  L.syncDoc(main, st);
+  const d = L.stageDurations(st);
+  const next = L.sw(st, 'dev') ? '개발(task-dev)' : '테스트(task-test)';
+  const fileNote = L.sw(st, 'dev') ? `, 계획 파일 ${files.length}개` : '';
+  return `${L.taskLabel(num)} 계획을 기록했다 — 시작·기획 ${L.minutes(d.plan)}${fileNote}.\n다음: ${next}.`;
+}
+
+// 등록된 코드 테스트를 dir에서 차례로 실행한다. 실패하면 멈춤 오류를 던진다
+async function runCodeTests(main, dir) {
+  const manifest = L.requireInstalled(main);
+  const cmds = manifest.codeTest;
+  if (cmds === 'none') return { none: true, ms: 0, outputs: [] };
+  if (!Array.isArray(cmds) || cmds.length === 0) {
+    L.fail(
+      'test-code: 등록된 코드 테스트 명령이 없다. 리포를 보고 화면을 켜지 않는 코드 테스트 명령(린트·타입·빌드·단위 테스트)을 정해 ' +
+        "`test-code --register \"<명령>\" [\"<명령>\" …]`으로 등록한 뒤 다시 부른다. 코드 테스트가 없는 리포면 `test-code --register none`.",
+    );
+  }
+  let total = 0;
+  const outputs = [];
+  for (const cmd of cmds) {
+    const r = await L.runShell(cmd, dir);
+    total += r.ms;
+    if (r.code !== 0) {
+      L.fail(`test-code: 실패 — \`${cmd}\` (종료 코드 ${r.code})\n--- 출력 끝부분 ---\n${L.tail(r.out, 60)}\n---\n원인을 고친 뒤 다시 부른다.${overNotice(total, cmds)}`);
+    }
+    outputs.push({ cmd, out: r.out });
+  }
+  return { none: false, ms: total, outputs };
+}
+
+function overNotice(totalMs, cmds) {
+  if (totalMs <= L.CODE_TEST_NOTICE_MS) return '';
+  return (
+    `\n알림: 코드 테스트가 3분을 넘었다(${L.minutes(totalMs)}) — 화면을 켜는 테스트가 섞였는지 확인한다.\n` +
+    `지금 등록된 명령: ${cmds.map((c) => `\`${c}\``).join(', ')}\n` +
+    '바꾸려면 `test-code --register "<명령>" …`으로 목록 전체를 다시 등록한다.'
+  );
+}
+
+async function testCode(ctx, a) {
+  const main = ctx.main;
+  if (a.register) {
+    const list = a.register.map((s) => String(s).trim()).filter(Boolean);
+    if (!list.length) L.fail('test-code --register: 등록할 명령을 하나 이상 넣는다. 코드 테스트가 없는 리포면 `--register none`.');
+    const manifest = L.requireInstalled(main);
+    manifest.codeTest = list.length === 1 && list[0] === 'none' ? 'none' : list;
+    L.writeManifest(main, manifest);
+    return manifest.codeTest === 'none'
+      ? '코드 테스트 없음으로 등록했다 — test-code는 코드 지문만 남기고 통과한다.'
+      : `코드 테스트 명령 ${list.length}개를 등록했다(목록 전체를 바꿨다):\n${list.map((c) => `- ${c}`).join('\n')}`;
+  }
+  let st = null;
+  let dir;
+  if (a.task) {
+    st = L.readState(main, L.parseTaskNum(a.task));
+    if (st.closed) L.fail(`${L.taskLabel(st.num)}은 이미 닫혔다.`);
+    dir = L.workDir(main, st);
+  } else {
+    dir = L.git(ctx.cwd, ['rev-parse', '--show-toplevel']);
+  }
+  const result = await runCodeTests(main, dir);
+  const cmds = L.requireInstalled(main).codeTest;
+  const lines = [];
+  if (result.none) lines.push('코드 테스트 없음으로 등록된 리포 — 실행 없이 통과.');
+  else {
+    lines.push(`통과 — ${result.outputs.length}개 명령, ${L.minutes(result.ms)}.`);
+    for (const o of result.outputs) lines.push(`--- \`${o.cmd}\` 출력 끝부분 ---\n${L.tail(o.out, 15) || '(출력 없음)'}`);
+  }
+  if (st) {
+    st.testCode = { at: L.nowIso(), fingerprint: L.fingerprint(dir) };
+    L.writeState(main, st);
+    L.syncDoc(main, st);
+    L.appendResult(
+      main,
+      st,
+      result.none
+        ? `- 코드 테스트 · 등록된 명령 없음 · ${L.clock(st.testCode.at)}`
+        : `- 코드 테스트 · 통과 · 명령 ${result.outputs.length}개 · ${L.minutes(result.ms)} · ${L.clock(st.testCode.at)}`,
+    );
+    lines.push(`${L.taskLabel(st.num)} 개발 칸을 기록했다 — 개발 ${L.minutes(L.stageDurations(st).dev)}.`);
+  }
+  if (!result.none) lines.push(overNotice(result.ms, cmds).trim());
+  return lines.filter(Boolean).join('\n');
+}
+
+const RESULTS = ['pass', 'fail', 'accept'];
+
+function lastEntry(st, n) {
+  const list = (st.scenarios && st.scenarios[n]) || [];
+  return list[list.length - 1] || null;
+}
+
+async function testScenario(ctx, a) {
+  const main = ctx.main;
+  const num = L.parseTaskNum(a.task);
+  const st = L.readState(main, num);
+  if (st.closed) L.fail(`${L.taskLabel(num)}은 이미 닫혔다.`);
+  const criteria = L.parseCriteria(L.readDoc(main, st));
+  const n = parseInt(a.number, 10);
+  if (!criteria.length) L.fail('test-scenario: 태스크 문서 `## 테스트 계획`에 완료 기준이 없다.');
+  if (!(n >= 1 && n <= criteria.length)) L.fail(`test-scenario: 시나리오 번호는 1~${criteria.length} 중 하나다 (받음: '${a.number}').`);
+  const result = String(a.result || '').toLowerCase();
+  if (!RESULTS.includes(result)) L.fail("test-scenario: 결과는 pass · fail · accept 중 하나다.");
+  const text = String(a.text || '').trim();
+  if (!text) {
+    L.fail(
+      result === 'accept'
+        ? 'test-scenario accept: FAIL을 알고 넘어가자고 한 사용자의 말을 그대로 넣는다.'
+        : 'test-scenario: 증거(실행 출력, 화면 캡처 경로, 또는 사용자 확인 시각)를 넣는다. 증거 없는 PASS는 적지 않는다.',
+    );
+  }
+  if (result === 'accept') {
+    const last = lastEntry(st, n);
+    if (!last || last.result !== 'fail') L.fail(`test-scenario accept: 시나리오 ${n}의 마지막 결과가 FAIL일 때만 받는다.`);
+  }
+  const at = L.nowIso();
+  st.scenarios = st.scenarios || {};
+  st.scenarios[n] = st.scenarios[n] || [];
+  st.scenarios[n].push(result === 'accept' ? { result, quote: text, at } : { result, evidence: text, at });
+  const label = result === 'pass' ? 'PASS' : result === 'fail' ? 'FAIL' : 'FAIL 수락';
+  const body = result === 'accept' ? `사용자: "${text}"` : text;
+
+  // 모든 시나리오가 PASS거나 FAIL 뒤 accept면 테스트 칸을 채운다
+  let complete = true;
+  let accepted = false;
+  for (let i = 1; i <= criteria.length; i++) {
+    const last = lastEntry(st, i);
+    if (!last || last.result === 'fail') complete = false;
+    else if (last.result === 'accept') accepted = true;
+  }
+  if (complete) st.testDone = { at, accepted };
+  else delete st.testDone;
+  L.writeState(main, st);
+  L.appendResult(main, st, `- 시나리오 ${n} · ${label} · ${body} · ${L.clock(at)}`);
+  L.syncDoc(main, st);
+
+  const out = [`${L.taskLabel(num)} 시나리오 ${n}: ${label} 기록.`];
+  if (complete) out.push(`모든 시나리오가 끝났다 — 테스트 칸을 채웠다(${L.minutes(L.stageDurations(st).test)}${accepted ? ', FAIL 수락' : ''}). 다음: 마무리(task-close).`);
+  else {
+    const left = [];
+    for (let i = 1; i <= criteria.length; i++) {
+      const last = lastEntry(st, i);
+      if (!last) left.push(`${i}(결과 없음)`);
+      else if (last.result === 'fail') left.push(`${i}(FAIL)`);
+    }
+    out.push(`남은 시나리오: ${left.join(', ')}`);
+  }
+  return out.join('\n');
+}
+
+module.exports = { approvePlan, testCode, testScenario, runCodeTests, lastEntry };

package/bin/commands.js

@@ -0,0 +1,151 @@
+// 명령 정의표 — 이름·받는 값·할 일을 한 번만 적고, CLI 입구(taskery.js)와 MCP 도구(mcp.js)를 여기서 만든다(§5-3)
+const L = require('./lib');
+const { prepareTask } = require('./prepare');
+const { approvePlan, testCode, testScenario } = require('./check');
+const { verifyClose, commitTask, mergeTask, closeTask } = require('./finish');
+const { status } = require('./status');
+const { planInit } = require('./plan');
+const { backlogAdd, backlogGet, backlogMark } = require('./backlog');
+const { prune } = require('./prune');
+const { orcaDispatchTask, reportTask, waitReports } = require('./orche');
+
+// 인자 종류: positional(순서대로) · string(--이름 값) · bool(--이름) · list(--이름 값 값 …)
+const TASK = { name: 'task', positional: true, desc: '태스크 번호 (TASK-012 또는 12)' };
+const RANGE = { name: 'range', desc: '사용자가 새로 말한 진행 범위 — 태스크 문서 헤더 표의 범위 칸만 바꾼다' };
+
+const COMMANDS = [
+  {
+    name: 'status',
+    summary: '열린 태스크·단계 표·단계별 시간·문서 경로·워크트리 경로, 플랜별 시작할 수 있는 태스크를 보여 준다',
+    args: [],
+    run: status,
+  },
+  {
+    name: 'plan-init',
+    summary: '다음 플랜 번호로 .taskery/plans/<NNN>_<slug>/PLAN.md 틀을 만든다',
+    args: [
+      { name: 'slug', positional: true, desc: '플랜 이름 — 영문 kebab-case (필수)' },
+      { name: 'title', desc: '플랜 제목 (없으면 slug)' },
+    ],
+    run: planInit,
+  },
+  {
+    name: 'prepare-task',
+    summary: '태스크를 연다 — 번호·브랜치·워크트리·태스크 문서·기록',
+    args: [
+      { name: 'name', positional: true, desc: '태스크 제목 한 줄 (필수)' },
+      { name: 'slug', desc: '영문 kebab-case — 브랜치·문서 파일 이름 (필수)' },
+      { name: 'type', desc: 'feature · bug · improve · refactor · docs · chore (필수)' },
+      { name: 'size', desc: 'small · medium · large (필수)' },
+      { name: 'switch', desc: '켜진 스위치 목록, 예 plan,dev,test (기본 모두 켜짐)' },
+      { name: 'range', desc: '사용자가 말한 진행 범위 그대로 (기본 한 단계)' },
+      { name: 'plan', desc: '플랜 폴더 이름 (플랜이 하나면 생략)' },
+      { name: 'item', desc: 'PLAN.md 태스크 목록의 항목 번호' },
+      { name: 'from', desc: '옮겨 오는 백로그 번호 목록, 예 BL-3,BL-7' },
+      { name: 'dev', desc: '작업자 식별자 (GIT_RULE.md 브랜치 이름에 작업자 칸이 있을 때 필수)' },
+      { name: 'no-worktree', type: 'bool', desc: '워크트리 생략 — 사용자가 명시했을 때만' },
+      { name: 'no-branch', type: 'bool', desc: '브랜치·워크트리 생략 — 사용자가 명시했을 때만' },
+    ],
+    run: prepareTask,
+  },
+  {
+    name: 'approve-plan',
+    summary: '태스크 문서(요구사항·개발 계획·완료 기준)를 검사하고 계획 끝을 기록한다',
+    args: [TASK, RANGE],
+    run: approvePlan,
+  },
+  {
+    name: 'test-code',
+    summary: '등록된 코드 테스트를 실행한다(태스크를 주면 개발 칸 기록). --register로 명령 목록을 등록·교체한다',
+    args: [
+      { ...TASK, desc: '태스크 번호 (없으면 기록 없이 결과만)' },
+      { name: 'register', type: 'list', desc: '코드 테스트 명령 목록 — 부를 때마다 목록 전체를 바꾼다. 없으면 none' },
+      RANGE,
+    ],
+    run: testCode,
+  },
+  {
+    name: 'test-scenario',
+    summary: '완료 기준 시나리오 결과를 기록한다 — pass|fail "증거" 또는 accept "<사용자가 한 말>"',
+    args: [
+      TASK,
+      { name: 'number', positional: true, desc: '시나리오 번호' },
+      { name: 'result', positional: true, desc: 'pass · fail · accept' },
+      { name: 'text', positional: true, desc: 'pass·fail은 증거, accept는 사용자가 한 말' },
+      RANGE,
+    ],
+    run: testScenario,
+  },
+  { name: 'verify-close', summary: '마무리 검사만 한다', args: [TASK, RANGE], run: verifyClose },
+  { name: 'commit-task', summary: 'Phase별 코드 커밋만 하고 병합 확인 요약을 낸다', args: [TASK, RANGE], run: commitTask },
+  { name: 'merge-task', summary: '병합 잠금 안에서 부모 최신으로 rebase한 뒤 병합한다', args: [TASK, RANGE], run: mergeTask },
+  { name: 'close-task', summary: '워크트리·브랜치를 정리하고 태스크를 닫는다(주인이 본진에서)', args: [TASK], run: closeTask },
+  {
+    name: 'prune',
+    summary: '닫힌 태스크에 남은 워크트리·브랜치를 정리한다 — 기본은 항목마다 묻는다',
+    args: [{ name: 'yes', type: 'bool', desc: '묻지 않고 정리 — 사용자가 명시했을 때만. 커밋 안 된 변경이 있는 곳은 건너뛴다' }],
+    interactive: true,
+    run: prune,
+  },
+  {
+    name: 'backlog-add',
+    summary: '백로그 번호를 발급해 BACKLOG.md 열린 항목 맨 위에 빈 양식을 넣는다',
+    args: [
+      { name: 'title', positional: true, desc: '항목 제목 한 줄 (필수)' },
+      { name: 'type', desc: 'bug · improve · feature · refactor · docs · chore' },
+    ],
+    run: backlogAdd,
+  },
+  {
+    name: 'backlog-get',
+    summary: '번호를 주면 그 항목 전문, 없으면 열린 항목 목록(번호·종류·제목·상태)',
+    args: [{ name: 'id', positional: true, desc: '백로그 번호 (BL-3 또는 3)' }],
+    run: backlogGet,
+  },
+  {
+    name: 'backlog-mark',
+    summary: '--from 없이 연 태스크를 백로그 항목에 연결한다(연결 태스크 칸·상태 진행)',
+    args: [
+      { name: 'id', positional: true, desc: '백로그 번호 (BL-3 또는 3)' },
+      { name: 'task', positional: true, desc: '태스크 번호 (TASK-012 또는 12)' },
+    ],
+    run: backlogMark,
+  },
+  {
+    name: 'orca-dispatch-task',
+    summary: 'Orca 새 탭에 태스크 세션을 띄우고 첫 지시문을 보낸다(Orca 전용). 탭 handle은 .state에 기록한다',
+    args: [
+      TASK,
+      { name: 'agent', desc: 'claude · codex (필수)' },
+      { name: 'model', desc: '에이전트 모델 — 사용자가 정한 것 (필수)' },
+      { name: 'note', desc: '첫 지시문 끝에 붙일 오케스트레이션의 말 한 줄' },
+    ],
+    run: orcaDispatchTask,
+  },
+  {
+    name: 'report-task',
+    summary: '태스크 세션이 오케스트레이션에 보고 한 줄을 남긴다(.taskery/reports.log)',
+    args: [TASK, { name: 'text', positional: true, desc: '보고 한 줄 (필수)' }],
+    run: reportTask,
+  },
+  {
+    name: 'wait-reports',
+    summary: '안 읽은 보고가 생기면 그 줄들을 출력하고 끝난다. 보고 없이 10분이면 오래 조용한 태스크 탭 목록과 함께 끝난다(백그라운드 셸로 건다)',
+    args: [],
+    cliOnly: true,
+    run: waitReports,
+  },
+];
+
+// 명령 실행 공통 — 본진을 찾고, --range가 있으면 범위를 먼저 갱신한다
+// ask는 묻는 명령(prune)에 CLI가 넘기는 질문 함수다. MCP에는 없다
+async function execute(cmd, args, { cwd = process.cwd(), main = null, ask = null } = {}) {
+  const ctx = { cwd, main: main || L.findMain(cwd), ask };
+  if (args.range && args.task && cmd.args.includes(RANGE)) {
+    const st = L.readState(ctx.main, L.parseTaskNum(args.task));
+    L.updateRange(ctx.main, st, String(args.range));
+  }
+  return cmd.run(ctx, args);
+}
+
+module.exports = { COMMANDS, execute };