zigrix 0.1.0-alpha.0

package/dist/config/mutate.js

@@ -0,0 +1,61 @@
+import { defaultConfig } from './defaults.js';
+import { zigrixConfigSchema } from './schema.js';
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function clone(value) {
+    return structuredClone(value);
+}
+export function parseConfigInput(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+export function getValueAtPath(value, dottedPath) {
+    if (!dottedPath)
+        return value;
+    return dottedPath.split('.').reduce((acc, key) => {
+        if (acc && typeof acc === 'object' && key in acc) {
+            return acc[key];
+        }
+        return undefined;
+    }, value);
+}
+export function setValueAtPath(target, dottedPath, nextValue) {
+    const root = clone(target);
+    const keys = dottedPath.split('.').filter(Boolean);
+    if (keys.length === 0) {
+        return clone(nextValue);
+    }
+    let cursor = root;
+    for (const key of keys.slice(0, -1)) {
+        const current = cursor[key];
+        if (!isObject(current)) {
+            cursor[key] = {};
+        }
+        cursor = cursor[key];
+    }
+    cursor[keys.at(-1)] = clone(nextValue);
+    return root;
+}
+export function resetValueAtPath(config, dottedPath) {
+    const defaults = clone(defaultConfig);
+    if (!dottedPath || dottedPath === 'all') {
+        return zigrixConfigSchema.parse(defaults);
+    }
+    const defaultValue = getValueAtPath(defaults, dottedPath);
+    if (defaultValue === undefined) {
+        throw new Error(`default path not found: ${dottedPath}`);
+    }
+    return zigrixConfigSchema.parse(setValueAtPath(config, dottedPath, defaultValue));
+}
+export function diffValues(current, baseline) {
+    return {
+        changed: JSON.stringify(current) !== JSON.stringify(baseline),
+        current,
+        baseline,
+    };
+}

package/dist/config/schema.d.ts

@@ -0,0 +1,132 @@
+import { z } from 'zod';
+export declare const zigrixConfigSchema: z.ZodObject<{
+    paths: z.ZodObject<{
+        baseDir: z.ZodString;
+        tasksDir: z.ZodString;
+        evidenceDir: z.ZodString;
+        promptsDir: z.ZodString;
+        eventsFile: z.ZodString;
+        indexFile: z.ZodString;
+        runsDir: z.ZodString;
+        rulesDir: z.ZodString;
+    }, z.core.$strip>;
+    workspace: z.ZodObject<{
+        projectsBaseDir: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    agents: z.ZodObject<{
+        registry: z.ZodRecord<z.ZodString, z.ZodObject<{
+            label: z.ZodString;
+            role: z.ZodString;
+            runtime: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        orchestration: z.ZodObject<{
+            participants: z.ZodArray<z.ZodString>;
+            excluded: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    rules: z.ZodObject<{
+        scales: z.ZodRecord<z.ZodString, z.ZodObject<{
+            requiredRoles: z.ZodArray<z.ZodString>;
+            optionalRoles: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        completion: z.ZodObject<{
+            requireQa: z.ZodBoolean;
+            requireEvidence: z.ZodBoolean;
+            requireUserReport: z.ZodBoolean;
+        }, z.core.$strip>;
+        stale: z.ZodObject<{
+            defaultHours: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    templates: z.ZodObject<{
+        workerPrompt: z.ZodObject<{
+            format: z.ZodDefault<z.ZodEnum<{
+                markdown: "markdown";
+                text: "text";
+            }>>;
+            version: z.ZodNumber;
+            placeholders: z.ZodArray<z.ZodString>;
+            body: z.ZodString;
+        }, z.core.$strip>;
+        finalReport: z.ZodObject<{
+            format: z.ZodDefault<z.ZodEnum<{
+                markdown: "markdown";
+                text: "text";
+            }>>;
+            version: z.ZodNumber;
+            placeholders: z.ZodArray<z.ZodString>;
+            body: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    runtime: z.ZodObject<{
+        outputMode: z.ZodEnum<{
+            text: "text";
+            json: "json";
+        }>;
+        jsonIndent: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ZigrixConfig = z.infer<typeof zigrixConfigSchema>;
+export declare const zigrixConfigJsonSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "ZigrixConfig";
+    readonly type: "object";
+    readonly required: readonly ["paths", "workspace", "agents", "rules", "templates", "runtime"];
+    readonly properties: {
+        readonly paths: {
+            readonly type: "object";
+            readonly required: readonly ["baseDir", "tasksDir", "evidenceDir", "promptsDir", "eventsFile", "indexFile", "runsDir", "rulesDir"];
+            readonly properties: {
+                readonly baseDir: {
+                    readonly type: "string";
+                };
+                readonly tasksDir: {
+                    readonly type: "string";
+                };
+                readonly evidenceDir: {
+                    readonly type: "string";
+                };
+                readonly promptsDir: {
+                    readonly type: "string";
+                };
+                readonly eventsFile: {
+                    readonly type: "string";
+                };
+                readonly indexFile: {
+                    readonly type: "string";
+                };
+                readonly runsDir: {
+                    readonly type: "string";
+                };
+                readonly rulesDir: {
+                    readonly type: "string";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly workspace: {
+            readonly type: "object";
+            readonly properties: {
+                readonly projectsBaseDir: {
+                    readonly type: "string";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly agents: {
+            readonly type: "object";
+        };
+        readonly rules: {
+            readonly type: "object";
+        };
+        readonly templates: {
+            readonly type: "object";
+        };
+        readonly runtime: {
+            readonly type: "object";
+        };
+    };
+    readonly additionalProperties: false;
+};

package/dist/config/schema.js

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+const roleSchema = z.string().min(1);
+const pathSchema = z.string().min(1);
+const agentSchema = z.object({
+    label: z.string().min(1),
+    role: z.string().min(1),
+    runtime: z.string().min(1),
+    enabled: z.boolean().default(true),
+    metadata: z.record(z.string(), z.unknown()).default({}),
+});
+const templateSchema = z.object({
+    format: z.enum(['markdown', 'text']).default('markdown'),
+    version: z.number().int().positive(),
+    placeholders: z.array(z.string().min(1)).min(1),
+    body: z.string().min(1),
+});
+export const zigrixConfigSchema = z.object({
+    paths: z.object({
+        baseDir: pathSchema,
+        tasksDir: pathSchema,
+        evidenceDir: pathSchema,
+        promptsDir: pathSchema,
+        eventsFile: pathSchema,
+        indexFile: pathSchema,
+        runsDir: pathSchema,
+        rulesDir: pathSchema,
+    }),
+    workspace: z.object({
+        projectsBaseDir: z.string().default(''),
+    }),
+    agents: z.object({
+        registry: z.record(z.string(), agentSchema),
+        orchestration: z.object({
+            participants: z.array(z.string()),
+            excluded: z.array(z.string()),
+        }),
+    }).superRefine((value, ctx) => {
+        const overlap = value.orchestration.participants.filter((item) => value.orchestration.excluded.includes(item));
+        for (const agentId of overlap) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `agent '${agentId}' cannot be both participant and excluded`,
+                path: ['orchestration', 'excluded'],
+            });
+        }
+        const knownAgents = new Set(Object.keys(value.registry));
+        for (const agentId of value.orchestration.participants) {
+            if (!knownAgents.has(agentId)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `participant '${agentId}' must exist in registry`,
+                    path: ['orchestration', 'participants'],
+                });
+            }
+        }
+        for (const agentId of value.orchestration.excluded) {
+            if (!knownAgents.has(agentId)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `excluded agent '${agentId}' must exist in registry`,
+                    path: ['orchestration', 'excluded'],
+                });
+            }
+        }
+    }),
+    rules: z.object({
+        scales: z.record(z.string(), z.object({
+            requiredRoles: z.array(roleSchema),
+            optionalRoles: z.array(roleSchema),
+        })),
+        completion: z.object({
+            requireQa: z.boolean(),
+            requireEvidence: z.boolean(),
+            requireUserReport: z.boolean(),
+        }),
+        stale: z.object({
+            defaultHours: z.number().positive(),
+        }),
+    }),
+    templates: z.object({
+        workerPrompt: templateSchema,
+        finalReport: templateSchema,
+    }),
+    runtime: z.object({
+        outputMode: z.enum(['text', 'json']),
+        jsonIndent: z.number().int().min(0).max(8),
+    }),
+});
+export const zigrixConfigJsonSchema = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    title: 'ZigrixConfig',
+    type: 'object',
+    required: ['paths', 'workspace', 'agents', 'rules', 'templates', 'runtime'],
+    properties: {
+        paths: {
+            type: 'object',
+            required: ['baseDir', 'tasksDir', 'evidenceDir', 'promptsDir', 'eventsFile', 'indexFile', 'runsDir', 'rulesDir'],
+            properties: {
+                baseDir: { type: 'string' },
+                tasksDir: { type: 'string' },
+                evidenceDir: { type: 'string' },
+                promptsDir: { type: 'string' },
+                eventsFile: { type: 'string' },
+                indexFile: { type: 'string' },
+                runsDir: { type: 'string' },
+                rulesDir: { type: 'string' },
+            },
+            additionalProperties: false,
+        },
+        workspace: {
+            type: 'object',
+            properties: {
+                projectsBaseDir: { type: 'string' },
+            },
+            additionalProperties: false,
+        },
+        agents: { type: 'object' },
+        rules: { type: 'object' },
+        templates: { type: 'object' },
+        runtime: { type: 'object' },
+    },
+    additionalProperties: false,
+};

package/dist/configure.d.ts

@@ -0,0 +1,24 @@
+import { type PathStabilizeResult, type SkillRegistrationResult } from './onboard.js';
+export interface ConfigureResult {
+    ok: boolean;
+    action: string;
+    configPath: string;
+    sections: string[];
+    agentsRegistered: string[];
+    agentsRemoved: string[];
+    agentsSkipped: string[];
+    rulesCopied: string[];
+    rulesSkipped: string[];
+    skillsResult: SkillRegistrationResult | null;
+    pathResult: PathStabilizeResult | null;
+    workspaceChanged: boolean;
+    warnings: string[];
+}
+export interface RunConfigureOptions {
+    sections?: string[];
+    yes?: boolean;
+    projectDir?: string;
+    projectsBaseDir?: string;
+    silent?: boolean;
+}
+export declare function runConfigure(options: RunConfigureOptions): Promise<ConfigureResult>;

package/dist/configure.js

@@ -0,0 +1,164 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { removeAgent } from './agents/registry.js';
+import { loadConfig, writeConfigFile } from './config/load.js';
+import { detectOpenClawHome, ensureZigrixInPath, filterAgents, loadOpenClawConfig, promptAgentSelection, registerAgents, registerSkills, seedRules, } from './onboard.js';
+import { resolvePaths } from './state/paths.js';
+const ALL_SECTIONS = ['agents', 'rules', 'workspace', 'path', 'skills'];
+// ─── Configure ────────────────────────────────────────────────────────────────
+export async function runConfigure(options) {
+    const warnings = [];
+    const silent = options.silent ?? false;
+    const log = (msg) => { if (!silent)
+        console.log(msg); };
+    // Resolve base dir at runtime (not from the static ZIGRIX_HOME constant)
+    const runtimeBaseDir = process.env.ZIGRIX_HOME
+        ? path.resolve(process.env.ZIGRIX_HOME)
+        : path.join(os.homedir(), '.zigrix');
+    const loaded = loadConfig({ baseDir: runtimeBaseDir });
+    if (!loaded.configPath || !fs.existsSync(loaded.configPath)) {
+        throw new Error('zigrix not initialized. Run `zigrix onboard` first.');
+    }
+    let config = structuredClone(loaded.config);
+    const configPath = loaded.configPath;
+    const paths = resolvePaths(config);
+    const sections = options.sections && options.sections.length > 0
+        ? options.sections
+        : [...ALL_SECTIONS];
+    let agentsRegistered = [];
+    let agentsRemoved = [];
+    let agentsSkipped = [];
+    let rulesCopied = [];
+    let rulesSkipped = [];
+    let skillsResult = null;
+    let pathResult = null;
+    let workspaceChanged = false;
+    let configDirty = false;
+    // ─── agents ───────────────────────────────────────────────────────────
+    if (sections.includes('agents')) {
+        const openclawHome = detectOpenClawHome();
+        const openclawConfig = loadOpenClawConfig(openclawHome);
+        if (openclawConfig) {
+            const allAgents = filterAgents(openclawConfig.agents?.list ?? []);
+            let selectedAgents;
+            if (options.yes) {
+                selectedAgents = allAgents;
+            }
+            else {
+                log('\n── Agent Configuration ──');
+                selectedAgents = await promptAgentSelection(allAgents);
+            }
+            if (selectedAgents.length > 0) {
+                const result = registerAgents(config, selectedAgents);
+                config = result.config;
+                agentsRegistered = result.registered;
+                agentsSkipped = result.skipped;
+                if (result.registered.length > 0)
+                    configDirty = true;
+            }
+            // Remove agents not in selection (unless --yes which means "keep all")
+            if (!options.yes && allAgents.length > 0) {
+                const selectedIds = new Set(selectedAgents.map((a) => a.id));
+                for (const agent of allAgents) {
+                    if (!selectedIds.has(agent.id) && config.agents.registry[agent.id]) {
+                        const result = removeAgent(config, agent.id);
+                        config = result.config;
+                        agentsRemoved.push(agent.id);
+                        configDirty = true;
+                    }
+                }
+            }
+            if (agentsRegistered.length > 0)
+                log(`✅ Registered: ${agentsRegistered.join(', ')}`);
+            if (agentsRemoved.length > 0)
+                log(`🗑️  Removed: ${agentsRemoved.join(', ')}`);
+            if (agentsSkipped.length > 0)
+                log(`⏭️  Unchanged: ${agentsSkipped.join(', ')}`);
+        }
+        else {
+            warnings.push('OpenClaw config not found — agent reconfiguration skipped.');
+            log(`⚠️  ${warnings[warnings.length - 1]}`);
+        }
+    }
+    // ─── workspace ────────────────────────────────────────────────────────
+    if (sections.includes('workspace') && options.projectsBaseDir) {
+        const resolved = path.resolve(options.projectsBaseDir);
+        if (config.workspace.projectsBaseDir !== resolved) {
+            config.workspace.projectsBaseDir = resolved;
+            configDirty = true;
+            workspaceChanged = true;
+            log(`✅ Projects base dir set to: ${resolved}`);
+        }
+    }
+    // ─── rules ────────────────────────────────────────────────────────────
+    if (sections.includes('rules')) {
+        const projectDir = options.projectDir ?? process.cwd();
+        const rulesSourceDir = path.join(projectDir, 'orchestration', 'rules');
+        if (fs.existsSync(rulesSourceDir)) {
+            const result = seedRules(rulesSourceDir, paths.rulesDir);
+            rulesCopied = result.copied;
+            rulesSkipped = result.skipped;
+            if (rulesCopied.length > 0)
+                log(`✅ Rules added: ${rulesCopied.join(', ')}`);
+            if (rulesSkipped.length > 0)
+                log(`⏭️  Rules unchanged: ${rulesSkipped.join(', ')}`);
+        }
+        else {
+            log(`ℹ️  No orchestration/rules/ at ${projectDir} — rule seeding skipped.`);
+        }
+    }
+    // ─── path ─────────────────────────────────────────────────────────────
+    if (sections.includes('path')) {
+        pathResult = ensureZigrixInPath();
+        if (pathResult.symlinkCreated) {
+            log(`✅ zigrix symlinked to ${pathResult.symlinkPath}`);
+        }
+        else if (pathResult.alreadyInPath) {
+            log('✅ zigrix already in PATH');
+        }
+        if (pathResult.warning) {
+            warnings.push(pathResult.warning);
+            log(`⚠️  ${pathResult.warning}`);
+        }
+    }
+    // ─── skills ───────────────────────────────────────────────────────────
+    if (sections.includes('skills')) {
+        const openclawHome = detectOpenClawHome();
+        if (fs.existsSync(openclawHome)) {
+            skillsResult = registerSkills(openclawHome);
+            if (skillsResult.registered.length > 0) {
+                log(`✅ Skills registered: ${skillsResult.registered.join(', ')}`);
+            }
+            if (skillsResult.skipped.length > 0) {
+                log(`⏭️  Skills unchanged: ${skillsResult.skipped.join(', ')}`);
+            }
+            for (const f of skillsResult.failed) {
+                warnings.push(`Skill failed: ${f}`);
+                log(`⚠️  ${warnings[warnings.length - 1]}`);
+            }
+        }
+        else {
+            log('ℹ️  OpenClaw not detected — skill registration skipped.');
+        }
+    }
+    // ─── persist ──────────────────────────────────────────────────────────
+    if (configDirty) {
+        writeConfigFile(configPath, config);
+    }
+    return {
+        ok: true,
+        action: 'configure',
+        configPath,
+        sections,
+        agentsRegistered,
+        agentsRemoved,
+        agentsSkipped,
+        rulesCopied,
+        rulesSkipped,
+        skillsResult,
+        pathResult,
+        workspaceChanged,
+        warnings,
+    };
+}

package/dist/doctor.d.ts

@@ -0,0 +1,4 @@
+import type { LoadedConfig } from './config/load.js';
+import type { ZigrixPaths } from './state/paths.js';
+export declare function gatherDoctor(loaded: LoadedConfig, paths: ZigrixPaths): Record<string, unknown>;
+export declare function renderDoctorText(payload: Record<string, any>): string;

package/dist/doctor.js

@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import path from 'node:path';
+function existsWritable(targetPath) {
+    try {
+        return fs.existsSync(targetPath) ? fs.accessSync(targetPath, fs.constants.W_OK) === undefined : fs.accessSync(path.dirname(targetPath), fs.constants.W_OK) === undefined;
+    }
+    catch {
+        return false;
+    }
+}
+function detectOpenClawHome() {
+    return process.env.OPENCLAW_HOME ? path.resolve(process.env.OPENCLAW_HOME) : path.join(process.env.HOME ?? '~', '.openclaw');
+}
+export function gatherDoctor(loaded, paths) {
+    const openclawHome = detectOpenClawHome();
+    const openclawSkillsDir = path.join(openclawHome, 'skills');
+    const warnings = [];
+    const rulesDir = paths.rulesDir;
+    const ruleFiles = fs.existsSync(rulesDir)
+        ? fs.readdirSync(rulesDir).filter((f) => f.endsWith('.md')).sort()
+        : [];
+    const payload = {
+        node: {
+            executable: process.execPath,
+            version: process.versions.node,
+            ok: Number(process.versions.node.split('.')[0]) >= 22,
+        },
+        paths: {
+            baseDir: loaded.baseDir,
+            configPath: loaded.configPath,
+            tasksDir: paths.tasksDir,
+            promptsDir: paths.promptsDir,
+            evidenceDir: paths.evidenceDir,
+            runsDir: paths.runsDir,
+            rulesDir: paths.rulesDir,
+        },
+        files: {
+            configExists: loaded.configPath ? fs.existsSync(loaded.configPath) : false,
+            baseDirExists: fs.existsSync(paths.baseDir),
+            indexExists: fs.existsSync(paths.indexFile),
+            eventsExists: fs.existsSync(paths.eventsFile),
+        },
+        rules: {
+            dir: rulesDir,
+            exists: fs.existsSync(rulesDir),
+            files: ruleFiles,
+            count: ruleFiles.length,
+        },
+        writeAccess: {
+            baseDir: existsWritable(paths.baseDir),
+            configPath: loaded.configPath ? existsWritable(loaded.configPath) : existsWritable(path.join(paths.baseDir, 'zigrix.config.json')),
+        },
+        binaries: {
+            node: process.execPath,
+            npm: process.env.npm_execpath ?? null,
+            openclaw: null,
+        },
+        openclaw: {
+            home: openclawHome,
+            exists: fs.existsSync(openclawHome),
+            skillsDir: openclawSkillsDir,
+            skillsDirExists: fs.existsSync(openclawSkillsDir),
+        },
+    };
+    if (!payload.node.ok)
+        warnings.push('Node.js 22+ is required.');
+    if (!payload.files.configExists)
+        warnings.push('zigrix.config.json not found. Run `zigrix onboard`.');
+    if (!payload.files.baseDirExists)
+        warnings.push('~/.zigrix not found. Run `zigrix onboard`.');
+    if (!payload.writeAccess.baseDir)
+        warnings.push('Base directory is not writable.');
+    if (!payload.openclaw.exists)
+        warnings.push('~/.openclaw not found. OpenClaw integration remains optional.');
+    if (payload.rules.count === 0)
+        warnings.push('No rule files found in rules directory. Seed from orchestration/rules/.');
+    return {
+        ...payload,
+        summary: {
+            ready: payload.node.ok && payload.writeAccess.baseDir && payload.files.configExists,
+            warnings,
+        },
+    };
+}
+export function renderDoctorText(payload) {
+    const lines = [
+        'Zigrix Doctor',
+        `- Node: ${payload.node.version} (${payload.node.ok ? 'ok' : 'too old'})`,
+        `- Base dir: ${payload.paths.baseDir}`,
+        `- Config: ${payload.paths.configPath ?? 'missing'}`,
+        `- Rules dir: ${payload.rules.dir} (${payload.rules.count} files)`,
+        `- OpenClaw home: ${payload.openclaw.home} (${payload.openclaw.exists ? 'present' : 'missing'})`,
+        `- Ready: ${payload.summary.ready ? 'yes' : 'no'}`,
+    ];
+    for (const warning of payload.summary.warnings) {
+        lines.push(`- Warning: ${warning}`);
+    }
+    return lines.join('\n');
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};