zigrix 0.1.0-alpha.0

package/dist/orchestration/worker.js

@@ -0,0 +1,132 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { appendEvent } from '../state/events.js';
+import { ensureBaseState } from '../state/paths.js';
+import { loadTask, saveTask } from '../state/tasks.js';
+export const DEFAULT_REQUIRED_AGENTS = ['pro-zig', 'qa-zig'];
+export function resolveRequiredAgents(task) {
+    for (const key of ['requiredAgents', 'selectedAgents', 'baselineRequiredAgents']) {
+        const value = task[key];
+        if (Array.isArray(value) && value.length > 0) {
+            return value.map(String);
+        }
+    }
+    const workers = task.workerSessions;
+    if (workers && typeof workers === 'object' && Object.keys(workers).length > 0) {
+        return Object.keys(workers).sort();
+    }
+    return [...DEFAULT_REQUIRED_AGENTS];
+}
+function renderPrompt(params) {
+    const sections = [
+        `## Worker Assignment: ${params.task.taskId}`,
+        '',
+        '| Field | Value |',
+        '|---|---|',
+        `| taskId | ${params.task.taskId} |`,
+        `| title | ${params.task.title} |`,
+        `| scale | ${params.task.scale} |`,
+        `| role | ${params.agentId} |`,
+        ...(params.projectDir ? [`| projectDir | ${params.projectDir} |`] : []),
+        '',
+        '### Assignment',
+        params.description,
+    ];
+    if (params.constraints)
+        sections.push('', '### Constraints', params.constraints);
+    if (params.dod)
+        sections.push('', '### Definition of Done', params.dod);
+    if (params.unitId || params.workPackage) {
+        sections.push('', '### Execution Context', `- unitId: ${params.unitId ?? 'N/A'}`, `- workPackage: ${params.workPackage ?? 'N/A'}`);
+    }
+    sections.push('', '### Completion', '작업 완료 후 결과와 근거를 명확히 보고하라.');
+    return sections.join('\n');
+}
+export function prepareWorker(paths, params) {
+    ensureBaseState(paths);
+    const task = loadTask(paths, params.taskId);
+    if (!task)
+        return null;
+    const projectDir = params.projectDir ?? task.projectDir;
+    const prompt = renderPrompt({ task, ...params, projectDir });
+    const promptPath = path.join(paths.promptsDir, `${params.taskId}-${params.agentId}.md`);
+    fs.writeFileSync(promptPath, `${prompt}\n`, 'utf8');
+    task.workerSessions[params.agentId] = {
+        status: 'prepared',
+        unitId: params.unitId,
+        workPackage: params.workPackage,
+        promptPath,
+    };
+    const required = task.requiredAgents.length > 0 ? task.requiredAgents : resolveRequiredAgents(task);
+    if (!required.includes(params.agentId))
+        required.push(params.agentId);
+    task.requiredAgents = required;
+    saveTask(paths, task);
+    appendEvent(paths.eventsFile, {
+        event: 'worker_prepared',
+        taskId: params.taskId,
+        phase: 'execution',
+        actor: 'zigrix',
+        targetAgent: params.agentId,
+        status: 'IN_PROGRESS',
+        unitId: params.unitId,
+        workPackage: params.workPackage,
+        payload: { agentId: params.agentId, description: params.description, constraints: params.constraints ?? '', dod: params.dod ?? '', promptPath },
+    });
+    return { ok: true, taskId: params.taskId, agentId: params.agentId, promptPath, prompt, unitId: params.unitId, workPackage: params.workPackage };
+}
+export function registerWorker(paths, params) {
+    const task = loadTask(paths, params.taskId);
+    if (!task)
+        return null;
+    task.workerSessions[params.agentId] = {
+        ...(task.workerSessions[params.agentId] ?? {}),
+        status: 'dispatched',
+        sessionKey: params.sessionKey,
+        runId: params.runId ?? '',
+        sessionId: params.sessionId ?? null,
+        unitId: params.unitId,
+        workPackage: params.workPackage,
+        reason: params.reason ?? '',
+    };
+    const required = task.requiredAgents.length > 0 ? task.requiredAgents : resolveRequiredAgents(task);
+    if (!required.includes(params.agentId))
+        required.push(params.agentId);
+    task.requiredAgents = required;
+    saveTask(paths, task);
+    appendEvent(paths.eventsFile, {
+        event: 'worker_dispatched', taskId: params.taskId, phase: 'execution', actor: 'zigrix', targetAgent: params.agentId, status: 'IN_PROGRESS',
+        sessionKey: params.sessionKey, sessionId: params.sessionId ?? null, unitId: params.unitId, workPackage: params.workPackage,
+        payload: { agentId: params.agentId, runId: params.runId ?? '', reason: params.reason ?? '' },
+    });
+    return { ok: true, taskId: params.taskId, agentId: params.agentId, sessionKey: params.sessionKey, runId: params.runId ?? '', sessionId: params.sessionId ?? null, unitId: params.unitId, workPackage: params.workPackage, status: 'dispatched' };
+}
+export function completeWorker(paths, params) {
+    const task = loadTask(paths, params.taskId);
+    if (!task)
+        return null;
+    const prev = task.workerSessions[params.agentId] ?? {};
+    task.workerSessions[params.agentId] = {
+        ...prev,
+        status: params.result ?? 'done',
+        sessionKey: params.sessionKey,
+        runId: params.runId,
+        sessionId: params.sessionId ?? prev.sessionId ?? null,
+        unitId: params.unitId ?? prev.unitId,
+        workPackage: params.workPackage ?? prev.workPackage,
+    };
+    saveTask(paths, task);
+    appendEvent(paths.eventsFile, {
+        event: 'worker_done', taskId: params.taskId, phase: 'execution', actor: params.agentId, targetAgent: params.agentId,
+        status: (params.result ?? 'done') === 'blocked' ? 'BLOCKED' : 'IN_PROGRESS', sessionKey: params.sessionKey, sessionId: params.sessionId ?? null,
+        unitId: params.unitId ?? prev.unitId, workPackage: params.workPackage ?? prev.workPackage,
+        payload: { result: params.result ?? 'done', runId: params.runId },
+    });
+    const evidenceDir = path.join(paths.evidenceDir, params.taskId);
+    const presentAgents = fs.existsSync(evidenceDir)
+        ? fs.readdirSync(evidenceDir).filter((file) => file.endsWith('.json') && file !== '_merged.json').map((file) => path.basename(file, '.json')).sort()
+        : [];
+    const required = resolveRequiredAgents(task);
+    const missingAgents = required.filter((agentId) => !presentAgents.includes(agentId));
+    return { ok: true, taskId: params.taskId, agentId: params.agentId, result: params.result ?? 'done', requiredAgents: required, presentEvidenceAgents: presentAgents, missingEvidenceAgents: missingAgents, allEvidenceCollected: missingAgents.length === 0 };
+}

package/dist/rules/templates.d.ts

@@ -0,0 +1,24 @@
+import { type ZigrixConfig } from '../config/schema.js';
+export declare const TEMPLATE_PLACEHOLDERS: {
+    readonly workerPrompt: readonly ["taskId", "title", "scale", "agentId", "description", "constraints", "requiredRoles", "workPackage", "unitId"];
+    readonly finalReport: readonly ["taskId", "title", "scale", "status", "summary", "missingAgents"];
+};
+export type TemplateKind = keyof typeof TEMPLATE_PLACEHOLDERS;
+export declare function listRules(config: ZigrixConfig): Array<{
+    path: string;
+    kind: 'policy' | 'template';
+}>;
+export declare function extractPlaceholders(body: string): string[];
+export declare function validateTemplate(kind: TemplateKind, body: string): {
+    ok: boolean;
+    placeholders: string[];
+    allowed: readonly string[];
+    unknown: string[];
+    missingRecommended: string[];
+};
+export declare function validateRules(config: ZigrixConfig): {
+    ok: boolean;
+    templates: Record<string, ReturnType<typeof validateTemplate>>;
+    invalidRoles: string[];
+};
+export declare function renderTemplate(kind: TemplateKind, body: string, context: Record<string, unknown>): string;

package/dist/rules/templates.js

@@ -0,0 +1,73 @@
+export const TEMPLATE_PLACEHOLDERS = {
+    workerPrompt: ['taskId', 'title', 'scale', 'agentId', 'description', 'constraints', 'requiredRoles', 'workPackage', 'unitId'],
+    finalReport: ['taskId', 'title', 'scale', 'status', 'summary', 'missingAgents'],
+};
+const PLACEHOLDER_RE = /{{\s*([a-zA-Z0-9_]+)\s*}}/g;
+export function listRules(config) {
+    return [
+        { path: 'rules.scales', kind: 'policy' },
+        { path: 'rules.completion', kind: 'policy' },
+        { path: 'rules.stale', kind: 'policy' },
+        { path: 'templates.workerPrompt', kind: 'template' },
+        { path: 'templates.finalReport', kind: 'template' },
+    ];
+}
+export function extractPlaceholders(body) {
+    const found = new Set();
+    for (const match of body.matchAll(PLACEHOLDER_RE)) {
+        const key = match[1]?.trim();
+        if (key)
+            found.add(key);
+    }
+    return [...found];
+}
+export function validateTemplate(kind, body) {
+    const placeholders = extractPlaceholders(body);
+    const allowed = TEMPLATE_PLACEHOLDERS[kind];
+    const unknown = placeholders.filter((item) => !allowed.includes(item));
+    const missingRecommended = allowed.filter((item) => !placeholders.includes(item));
+    return {
+        ok: unknown.length === 0,
+        placeholders,
+        allowed,
+        unknown,
+        missingRecommended,
+    };
+}
+export function validateRules(config) {
+    const knownRoles = new Set(Object.values(config.agents.registry).map((agent) => agent.role));
+    knownRoles.add('orchestrator');
+    knownRoles.add('qa');
+    knownRoles.add('frontend');
+    knownRoles.add('backend');
+    knownRoles.add('security');
+    knownRoles.add('infra');
+    const invalidRoles = new Set();
+    for (const scale of Object.values(config.rules.scales)) {
+        for (const role of [...scale.requiredRoles, ...scale.optionalRoles]) {
+            if (!knownRoles.has(role))
+                invalidRoles.add(role);
+        }
+    }
+    const templates = {
+        workerPrompt: validateTemplate('workerPrompt', config.templates.workerPrompt.body),
+        finalReport: validateTemplate('finalReport', config.templates.finalReport.body),
+    };
+    return {
+        ok: invalidRoles.size === 0 && Object.values(templates).every((item) => item.ok),
+        templates,
+        invalidRoles: [...invalidRoles].sort(),
+    };
+}
+export function renderTemplate(kind, body, context) {
+    return body.replaceAll(PLACEHOLDER_RE, (_full, key) => {
+        const value = context[key];
+        if (Array.isArray(value))
+            return value.join(', ');
+        if (value === undefined || value === null)
+            return '';
+        if (typeof value === 'object')
+            return JSON.stringify(value);
+        return String(value);
+    });
+}

package/dist/runner/run.d.ts

@@ -0,0 +1,10 @@
+import type { ZigrixConfig } from '../config/schema.js';
+import { type WorkflowRunRecord } from './schema.js';
+export declare function runWorkflow(params: {
+    config: ZigrixConfig;
+    workflowPath: string;
+}): Promise<{
+    record: WorkflowRunRecord;
+    savedPath: string;
+}>;
+export declare function summarizeRun(record: WorkflowRunRecord): string;

package/dist/runner/run.js

@@ -0,0 +1,91 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { saveRunRecord } from './store.js';
+import { workflowSchema } from './schema.js';
+function nowIso() {
+    return new Date().toISOString();
+}
+function runStep(step, cwd) {
+    const startedAt = new Date();
+    return new Promise((resolve) => {
+        const child = spawn(step.run, {
+            cwd,
+            env: process.env,
+            shell: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        child.stdout.on('data', (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        const timeout = step.timeoutMs
+            ? setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGTERM');
+            }, step.timeoutMs)
+            : null;
+        child.on('close', (code) => {
+            if (timeout)
+                clearTimeout(timeout);
+            const finishedAt = new Date();
+            resolve({
+                id: step.id,
+                run: step.run,
+                cwd,
+                status: timedOut ? 'timeout' : code === 0 ? 'success' : 'failed',
+                exitCode: code,
+                startedAt: startedAt.toISOString(),
+                finishedAt: finishedAt.toISOString(),
+                durationMs: finishedAt.getTime() - startedAt.getTime(),
+                stdout,
+                stderr,
+            });
+        });
+    });
+}
+export async function runWorkflow(params) {
+    const workflowPath = path.resolve(params.workflowPath);
+    const raw = fs.readFileSync(workflowPath, 'utf8');
+    const parsed = workflowSchema.parse(JSON.parse(raw));
+    const workflowDir = path.dirname(workflowPath);
+    const startedAt = new Date();
+    const runId = `run-${startedAt.toISOString().replace(/[:.]/g, '-').replace('T', '_').slice(0, 19)}`;
+    const steps = [];
+    let overallStatus = 'success';
+    for (const step of parsed.steps) {
+        const cwd = step.cwd ? path.resolve(workflowDir, step.cwd) : workflowDir;
+        const result = await runStep(step, cwd);
+        steps.push(result);
+        if (result.status !== 'success') {
+            overallStatus = 'failed';
+            break;
+        }
+    }
+    const finishedAt = new Date();
+    const record = {
+        runId,
+        workflowName: parsed.name,
+        workflowPath,
+        status: overallStatus,
+        startedAt: startedAt.toISOString(),
+        finishedAt: finishedAt.toISOString(),
+        durationMs: finishedAt.getTime() - startedAt.getTime(),
+        steps,
+    };
+    const savedPath = saveRunRecord(params.config, record);
+    return { record, savedPath };
+}
+export function summarizeRun(record) {
+    return [
+        `runId: ${record.runId}`,
+        `workflow: ${record.workflowName}`,
+        `status: ${record.status}`,
+        `steps: ${record.steps.length}`,
+        `durationMs: ${record.durationMs}`,
+    ].join('\n');
+}

package/dist/runner/schema.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const workflowSchema: z.ZodObject<{
+    name: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        run: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Workflow = z.infer<typeof workflowSchema>;
+export type StepRunRecord = {
+    id: string;
+    run: string;
+    cwd: string;
+    status: 'success' | 'failed' | 'timeout';
+    exitCode: number | null;
+    startedAt: string;
+    finishedAt: string;
+    durationMs: number;
+    stdout: string;
+    stderr: string;
+};
+export type WorkflowRunRecord = {
+    runId: string;
+    workflowName: string;
+    workflowPath: string;
+    status: 'success' | 'failed';
+    startedAt: string;
+    finishedAt: string;
+    durationMs: number;
+    steps: StepRunRecord[];
+};

package/dist/runner/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export const workflowSchema = z.object({
+    name: z.string().min(1),
+    steps: z.array(z.object({
+        id: z.string().min(1),
+        run: z.string().min(1),
+        cwd: z.string().optional(),
+        timeoutMs: z.number().int().positive().max(3_600_000).optional(),
+    })).min(1),
+});

package/dist/runner/store.d.ts

@@ -0,0 +1,5 @@
+import type { ZigrixConfig } from '../config/schema.js';
+import type { WorkflowRunRecord } from './schema.js';
+export declare function ensureRunsDir(config: ZigrixConfig): string;
+export declare function saveRunRecord(config: ZigrixConfig, record: WorkflowRunRecord): string;
+export declare function loadRunRecord(config: ZigrixConfig, runIdOrPath: string): WorkflowRunRecord;

package/dist/runner/store.js

@@ -0,0 +1,19 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function ensureRunsDir(config) {
+    const runsDir = config.paths.runsDir;
+    fs.mkdirSync(runsDir, { recursive: true });
+    return runsDir;
+}
+export function saveRunRecord(config, record) {
+    const runsDir = ensureRunsDir(config);
+    const filePath = path.join(runsDir, `${record.runId}.json`);
+    fs.writeFileSync(filePath, `${JSON.stringify(record, null, config.runtime.jsonIndent)}\n`, 'utf8');
+    return filePath;
+}
+export function loadRunRecord(config, runIdOrPath) {
+    const candidatePath = path.isAbsolute(runIdOrPath)
+        ? runIdOrPath
+        : path.join(config.paths.runsDir, runIdOrPath.endsWith('.json') ? runIdOrPath : `${runIdOrPath}.json`);
+    return JSON.parse(fs.readFileSync(candidatePath, 'utf8'));
+}

package/dist/state/events.d.ts

@@ -0,0 +1,3 @@
+export declare function nowIso(): string;
+export declare function appendEvent(eventsFile: string, event: Record<string, unknown>): Record<string, unknown>;
+export declare function loadEvents(eventsFile: string): Array<Record<string, unknown>>;

package/dist/state/events.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function nowIso() {
+    return new Date().toISOString();
+}
+/**
+ * Normalize a legacy event to the standard envelope.
+ * - `timestamp` → `ts`
+ * - top-level `agentId`/`reason` → payload
+ */
+function normalizeEvent(raw) {
+    const event = { ...raw };
+    // timestamp → ts
+    if ('timestamp' in event && !('ts' in event)) {
+        event.ts = event.timestamp;
+        delete event.timestamp;
+    }
+    // Ensure payload exists
+    if (!event.payload || typeof event.payload !== 'object') {
+        event.payload = {};
+    }
+    const payload = event.payload;
+    // Move top-level agentId/reason into payload if not already there
+    if ('agentId' in event && event.agentId !== undefined && !('agentId' in payload)) {
+        payload.agentId = event.agentId;
+    }
+    if ('reason' in event && event.reason !== undefined && !('reason' in payload)) {
+        payload.reason = event.reason;
+    }
+    return event;
+}
+export function appendEvent(eventsFile, event) {
+    const payload = { ...event, ts: event.ts ?? nowIso() };
+    fs.mkdirSync(path.dirname(eventsFile), { recursive: true });
+    fs.appendFileSync(eventsFile, `${JSON.stringify(payload)}\n`, 'utf8');
+    return payload;
+}
+export function loadEvents(eventsFile) {
+    if (!fs.existsSync(eventsFile))
+        return [];
+    return fs.readFileSync(eventsFile, 'utf8')
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .flatMap((line) => {
+        try {
+            const parsed = JSON.parse(line);
+            return [normalizeEvent(parsed)];
+        }
+        catch {
+            return [];
+        }
+    });
+}

package/dist/state/paths.d.ts

@@ -0,0 +1,15 @@
+import type { ZigrixConfig } from '../config/schema.js';
+export type ZigrixPaths = {
+    baseDir: string;
+    tasksDir: string;
+    promptsDir: string;
+    evidenceDir: string;
+    eventsFile: string;
+    indexFile: string;
+    runsDir: string;
+    rulesDir: string;
+};
+export declare function resolvePaths(config: ZigrixConfig): ZigrixPaths;
+export declare function ensureBaseState(paths: ZigrixPaths): void;
+/** @deprecated Use ensureBaseState */
+export declare const ensureProjectState: typeof ensureBaseState;

package/dist/state/paths.js

@@ -0,0 +1,23 @@
+import fs from 'node:fs';
+export function resolvePaths(config) {
+    return {
+        baseDir: config.paths.baseDir,
+        tasksDir: config.paths.tasksDir,
+        promptsDir: config.paths.promptsDir,
+        evidenceDir: config.paths.evidenceDir,
+        eventsFile: config.paths.eventsFile,
+        indexFile: config.paths.indexFile,
+        runsDir: config.paths.runsDir,
+        rulesDir: config.paths.rulesDir,
+    };
+}
+export function ensureBaseState(paths) {
+    fs.mkdirSync(paths.baseDir, { recursive: true });
+    fs.mkdirSync(paths.tasksDir, { recursive: true });
+    fs.mkdirSync(paths.promptsDir, { recursive: true });
+    fs.mkdirSync(paths.evidenceDir, { recursive: true });
+    fs.mkdirSync(paths.runsDir, { recursive: true });
+    fs.mkdirSync(paths.rulesDir, { recursive: true });
+}
+/** @deprecated Use ensureBaseState */
+export const ensureProjectState = ensureBaseState;

package/dist/state/tasks.d.ts

@@ -0,0 +1,61 @@
+import { type ZigrixPaths } from './paths.js';
+export type WorkPackage = {
+    id: string;
+    key: string;
+    title: string;
+    parallel: boolean;
+};
+export type ExecutionUnit = {
+    id: string;
+    title: string;
+    kind: string;
+    owner: string;
+    workPackage: string;
+    dependsOn: string[];
+    parallel: boolean;
+    status: string;
+    dod: string;
+};
+export type ZigrixTask = {
+    taskId: string;
+    title: string;
+    description: string;
+    scale: string;
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+    requiredAgents: string[];
+    workerSessions: Record<string, unknown>;
+    projectDir?: string;
+    requestedBy?: string;
+    selectedAgents?: string[];
+    workPackages?: WorkPackage[];
+    executionUnits?: ExecutionUnit[];
+    orchestratorSessionKey?: string;
+    orchestratorSessionId?: string;
+};
+export declare function nextTaskId(paths: ZigrixPaths, prefix?: string): string;
+export declare function saveTask(paths: ZigrixPaths, task: ZigrixTask): ZigrixTask;
+export declare function loadTask(paths: ZigrixPaths, taskId: string): ZigrixTask | null;
+export declare function listTasks(paths: ZigrixPaths): ZigrixTask[];
+export declare function listTaskEvents(paths: ZigrixPaths, taskId?: string): Array<Record<string, unknown>>;
+export declare function createTask(paths: ZigrixPaths, params: {
+    title: string;
+    description: string;
+    scale?: string;
+    requiredAgents?: string[];
+    projectDir?: string;
+    requestedBy?: string;
+    prefix?: string;
+}): ZigrixTask;
+export declare function updateTaskStatus(paths: ZigrixPaths, taskId: string, status: string): ZigrixTask | null;
+export declare function recordTaskProgress(paths: ZigrixPaths, params: {
+    taskId: string;
+    actor: string;
+    message: string;
+    unitId?: string;
+    workPackage?: string;
+}): Record<string, unknown> | null;
+export declare function findStaleTasks(paths: ZigrixPaths, hours?: number): ZigrixTask[];
+export declare function applyStalePolicy(paths: ZigrixPaths, hours?: number, reason?: string): Record<string, unknown>;
+export declare function rebuildIndex(paths: ZigrixPaths): Record<string, unknown>;