@capstone-nomos/cli 0.1.0

package/dist/executor/runner.js

@@ -0,0 +1,59 @@
+import { spawn } from 'node:child_process';
+import { existsSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { buildClaudeArgs } from '../bridge/claude-args.js';
+export const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+// ⚠️ Windows에서 spawn('claude', args, { shell: true })를 쓰면 안 된다.
+// shell:true는 인자를 이스케이프 없이 이어붙여서 따옴표·괄호가 든 프롬프트가 셸에 먹힌다
+// (스파이크에서 도구 호출이 한 번도 안 일어났다). .cmd 셰이퍼는 shell 없이 못 돌리므로
+// node로 CLI 진입점을 직접 띄운다.
+export function resolveClaudeCommand(args) {
+    if (process.platform === 'win32' && process.env.APPDATA) {
+        const cli = path.join(process.env.APPDATA, 'npm', 'node_modules', '@anthropic-ai', 'claude-code', 'cli-wrapper.cjs');
+        if (existsSync(cli))
+            return { command: process.execPath, commandArgs: [cli, ...args] };
+    }
+    return { command: 'claude', commandArgs: args };
+}
+export async function runClaude(input) {
+    const args = buildClaudeArgs({
+        prompt: input.prompt,
+        mcpConfigPath: input.mcpConfigPath,
+        cwd: input.workspaceDir,
+        ...(input.model === undefined ? {} : { model: input.model }),
+    });
+    const { command, commandArgs } = resolveClaudeCommand(args);
+    const logPath = path.join(input.workspaceDir, '.nomos-run.log');
+    const startedAt = Date.now();
+    return new Promise((resolve) => {
+        // stdin을 열어두면 claude가 파이프 입력을 몇 초간 기다린다. 쓸 일이 없으니 닫는다.
+        const child = spawn(command, commandArgs, {
+            cwd: input.workspaceDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const chunks = [];
+        const collect = (c) => chunks.push(c.toString());
+        child.stdout.on('data', collect);
+        child.stderr.on('data', collect);
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill();
+        }, input.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            writeFileSync(logPath, chunks.join(''));
+            resolve({
+                outcome: timedOut ? 'timeout' : code === 0 ? 'completed' : 'failed',
+                exitCode: code,
+                durationMs: Date.now() - startedAt,
+                logPath,
+            });
+        });
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            writeFileSync(logPath, `${chunks.join('')}\n[executor] spawn 실패: ${err.message}\n`);
+            resolve({ outcome: 'failed', exitCode: null, durationMs: Date.now() - startedAt, logPath });
+        });
+    });
+}

package/dist/executor/task-source.js

@@ -0,0 +1,10 @@
+// 서버가 에이전트 토큰을 보고 자기 역할로 필터해 준다 — 여기서 역할을 다시 거르지 않는다.
+export function pollingTaskSource(client, projectId) {
+    return {
+        kind: 'polling',
+        async nextTasks(limit) {
+            const rows = await client.listTasks(projectId, { state: 'READY', limit });
+            return rows;
+        },
+    };
+}

package/dist/executor/verify.js

@@ -0,0 +1,106 @@
+// V2(PM 시험지)와 V4(린트) — 작업공간이 있어야 돌 수 있는 두 단계.
+// 제출 시점에는 결과가 물리적으로 존재할 수 없으므로 서버가 동기로 돌릴 수 없고,
+// Executor가 돌린 뒤 POST /api/artifacts/:id/verifications로 보고한다.
+//
+// 여기서 판정하는 것은 "명령이 0으로 끝났는가"뿐이다. 출력을 읽고 해석하지 않는다 —
+// 해석이 들어가는 순간 브릿지마다 결과가 달라지고, 그건 결정적 검증이 아니다.
+import { execFile } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const run = promisify(execFile);
+// 린트와 테스트는 오래 걸릴 수 있지만 무한정은 아니다. 초과하면 SKIPPED로 남긴다 —
+// FAIL로 적으면 코드가 아니라 기계가 느려서 재시도 횟수를 잃는다.
+const STEP_TIMEOUT_MS = 5 * 60 * 1000;
+// Windows에서 npm은 .cmd라 shell 없이는 못 띄운다. 인자를 문자열로 합치지 않고
+// npm-cli.js를 직접 node로 부르는 방식이 안전하지만, 여기서는 인자가 고정이라
+// shell:true로도 주입 여지가 없다 — 사용자 입력이 섞이지 않는다.
+async function exec(cmd, args, cwd) {
+    try {
+        const { stdout, stderr } = await run(cmd, args, {
+            cwd,
+            timeout: STEP_TIMEOUT_MS,
+            shell: process.platform === 'win32',
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return { code: 0, stdout, stderr };
+    }
+    catch (err) {
+        const e = err;
+        return {
+            code: typeof e.code === 'number' ? e.code : e.killed ? 124 : 1,
+            stdout: e.stdout ?? '',
+            stderr: e.stderr ?? String(err),
+        };
+    }
+}
+// 출력 전체를 서버에 올리지 않는다. events·verifications는 지워지지 않으므로
+// 로그를 통째로 넣으면 비밀값이 섞여 들어갈 수 있다.
+function tail(text, lines = 20) {
+    return text.trim().split('\n').slice(-lines).join('\n');
+}
+function packageScripts(workspaceDir) {
+    const file = path.join(workspaceDir, 'package.json');
+    if (!existsSync(file))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf-8'));
+        return parsed.scripts ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+// ── V4 — 린트 ─────────────────────────────────────────────────────────────
+export async function runLint(workspaceDir) {
+    const started = Date.now();
+    const done = (result, detail) => ({ stage: 'V4', result, detail, durationMs: Date.now() - started });
+    const scripts = packageScripts(workspaceDir);
+    if (!('lint' in scripts)) {
+        return done('SKIPPED', { reason: 'package.json에 lint 스크립트가 없다' });
+    }
+    const out = await exec('npm', ['run', '--silent', 'lint'], workspaceDir);
+    if (out.code === 124)
+        return done('SKIPPED', { reason: '린트가 제한 시간을 넘겼다' });
+    return out.code === 0
+        ? done('PASS', { command: 'npm run lint' })
+        : done('FAIL', { command: 'npm run lint', exitCode: out.code, output: tail(out.stderr || out.stdout) });
+}
+const SPEC_TEST_DIR = '.nomos-spec-tests';
+export async function runSpecTests(workspaceDir, specTests) {
+    const started = Date.now();
+    const done = (result, detail) => ({ stage: 'V2', result, detail, durationMs: Date.now() - started });
+    if (specTests.length === 0) {
+        return done('SKIPPED', { reason: '잠긴 spec_tests가 없다' });
+    }
+    // vitest가 작업공간에 설치돼 있을 때만 돌린다. npx에 맡기면 없을 때 레지스트리에서
+    // 받아오느라 몇 분이 사라지고, 네트워크가 막힌 노트북에서는 그대로 멈춘다.
+    if (!existsSync(path.join(workspaceDir, 'node_modules', 'vitest'))) {
+        return done('SKIPPED', { reason: '작업공간에 vitest가 설치돼 있지 않다' });
+    }
+    const dir = path.join(workspaceDir, SPEC_TEST_DIR);
+    // 시험지는 작업 결과가 아니다. 커밋에 섞이면 V3에서 신고 누락으로 잡힌다.
+    rmSync(dir, { recursive: true, force: true });
+    mkdirSync(dir, { recursive: true });
+    try {
+        const files = specTests.map((t) => {
+            const file = path.join(dir, `${t.id}.test.ts`);
+            writeFileSync(file, t.testCode, 'utf-8');
+            return path.posix.join(SPEC_TEST_DIR, `${t.id}.test.ts`);
+        });
+        const out = await exec('npx', ['vitest', 'run', ...files], workspaceDir);
+        if (out.code === 124)
+            return done('SKIPPED', { reason: '시험지가 제한 시간을 넘겼다' });
+        return out.code === 0
+            ? done('PASS', { specTestIds: specTests.map((t) => t.id) })
+            : done('FAIL', {
+                specTestIds: specTests.map((t) => t.id),
+                exitCode: out.code,
+                output: tail(out.stdout || out.stderr),
+            });
+    }
+    finally {
+        // 남겨두면 다음 실행에서 모델이 시험지를 읽고 거기에 맞춰 고칠 수 있다.
+        rmSync(dir, { recursive: true, force: true });
+    }
+}

package/dist/executor/workspace.js

@@ -0,0 +1,92 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+// 작업공간은 레포 자체와 분리한다. git worktree로 분기하므로 사용자의 기존 작업 트리를 건드리지 않는다.
+// 태스크가 끝나도 남긴다 — 실패 원인은 로그가 아니라 남은 파일에서 드러나는 경우가 많다.
+export function workspacesRoot() {
+    return path.join(os.homedir(), '.nomos', 'workspaces');
+}
+export function workspaceDir(projectId, taskId) {
+    return path.join(workspacesRoot(), projectId, taskId);
+}
+// 레포 fullName → 이미 받아 둔 로컬 경로(선택). 없으면 CLI가 ~/.nomos/repos/에 받는다(repo-checkout.ts).
+export function repoMapPath() {
+    return path.join(os.homedir(), '.nomos', 'repos.json');
+}
+// 없으면 빈 맵. 시드는 "적힌 것만" 쓰면 되므로 실패시키지 않는다.
+export function readRepoMap() {
+    const file = repoMapPath();
+    if (!existsSync(file))
+        return {};
+    return JSON.parse(readFileSync(file, 'utf-8'));
+}
+function git(repoPath, args) {
+    return execFileSync('git', args, { cwd: repoPath, encoding: 'utf-8' }).trim();
+}
+function branchExists(repoPath, branch) {
+    try {
+        // stdio를 삼킨다 — 없는 브랜치면 git이 stderr에 fatal을 찍어 로그를 더럽힌다.
+        execFileSync('git', ['rev-parse', '--verify', `refs/heads/${branch}`], {
+            cwd: repoPath,
+            stdio: 'ignore',
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// .claude/settings.json이 **로컬 방어선**이다. 서버의 제출 시점 검증과 두 겹을 이룬다.
+// 생성에 쓴 policy_hash를 같이 남겨 둔다 — 나중에 agents.settings_hash 대조에 쓴다.
+export function prepareWorkspace(input) {
+    const dir = workspaceDir(input.projectId, input.taskId);
+    const branch = input.branchName ?? `task/${input.taskId}`;
+    const existed = branchExists(input.repoPath, branch);
+    if (!existsSync(dir)) {
+        mkdirSync(path.dirname(dir), { recursive: true });
+        const args = existed
+            ? ['worktree', 'add', dir, branch]
+            : ['worktree', 'add', '-b', branch, dir, input.baseBranch];
+        git(input.repoPath, args);
+    }
+    const claudeDir = path.join(dir, '.claude');
+    mkdirSync(claudeDir, { recursive: true });
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    writeFileSync(settingsPath, `${JSON.stringify(input.settings, null, 2)}\n`);
+    writeFileSync(path.join(claudeDir, '.nomos-policy.json'), `${JSON.stringify({ policyHash: input.policyHash, taskId: input.taskId, generatedAt: new Date().toISOString() }, null, 2)}\n`);
+    return { dir, branch, createdBranch: !existed, settingsPath };
+}
+// executor clean — worktree를 정리한다. 남겨두는 게 기본이라 정리는 명시적 명령으로만 한다.
+export function cleanWorkspaces() {
+    const pruned = [];
+    // repos.json에 적힌 레포 + CLI가 받아 둔 레포(~/.nomos/repos/<조직>/<레포>).
+    const repos = { ...readRepoMap() };
+    const managed = path.join(os.homedir(), '.nomos', 'repos');
+    if (existsSync(managed)) {
+        for (const owner of readdirSync(managed)) {
+            const ownerDir = path.join(managed, owner);
+            if (!statSync(ownerDir).isDirectory())
+                continue;
+            for (const name of readdirSync(ownerDir))
+                repos[`${owner}/${name}`] ??= path.join(ownerDir, name);
+        }
+    }
+    for (const [fullName, repoPath] of Object.entries(repos)) {
+        try {
+            git(repoPath, ['worktree', 'prune']);
+            pruned.push(fullName);
+        }
+        catch {
+            // 레포가 사라졌거나 git이 없어도 디렉터리 삭제는 진행한다.
+        }
+    }
+    const root = workspacesRoot();
+    if (!existsSync(root))
+        return { pruned, removed: null };
+    rmSync(root, { recursive: true, force: true });
+    return { pruned, removed: root };
+}
+export function headSha(dir) {
+    return execFileSync('git', ['rev-parse', 'HEAD'], { cwd: dir, encoding: 'utf-8' }).trim();
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@capstone-nomos/cli",
+  "version": "0.1.0",
+  "description": "NOMOS 에이전트 CLI — 노트북의 Claude Code를 NOMOS 서버에 연결하고 배정된 태스크를 실행한다",
+  "type": "module",
+  "bin": {
+    "nomos": "dist/executor/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "zod": "^3.24.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Capstone-NOMOS/backend.git",
+    "directory": "packages/cli"
+  },
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  }
+}