@hazeljs/cli 2.0.0 → 2.0.2

package/dist/commands/agent.js

@@ -37,19 +37,92 @@ exports.registerAgentCommand = registerAgentCommand;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const agent_templates_1 = require("./agent-templates");
 const DEFAULT_RUN_STORE = path.join('.hazel', 'agent-runs.json');
 const DEFAULT_DURABLE_DIR = path.join('.hazel', 'runs');
 const DEFAULT_TIMELINE = path.join('.hazel', 'runs', 'timeline.jsonl');
+const DEFAULT_PLATFORM_STORE = path.join('.hazel', 'platform', 'resources.json');
 /**
+ * `hazel agent new` — scaffold Agent OS / DNA templates (G2 template unification).
  * `hazel agent install <file.dna.json>` — validate / print marketplace install plan.
  * `hazel agent run` — live execute from DNA (AOS-011).
+ * `hazel agent apply|get|describe|delete|reconcile|events` — declarative platform resources (local control plane).
  * `hazel agent logs` / `doctor` — timeline + environment checks.
  * `hazel agent runs list|inspect|cancel|resume|approve` — durable store ops.
  */
 function registerAgentCommand(program) {
     const agent = program
         .command('agent')
-        .description('Agent OS DNA / runtime / marketplace helpers');
+        .description('Agent OS DNA / runtime / marketplace / platform helpers');
+    agent
+        .command('templates')
+        .description('List Agent OS / DNA project templates')
+        .option('--json', 'Print JSON')
+        .action((opts) => {
+        const templates = (0, agent_templates_1.listAgentTemplates)();
+        if (opts.json) {
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify({ ok: true, templates }, null, 2));
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.log('\nAgent OS templates (`hazel agent new <name> --template <id>`):\n');
+        for (const t of templates) {
+            // eslint-disable-next-line no-console
+            console.log(`  ${t.id.padEnd(12)} ${t.label}`);
+            // eslint-disable-next-line no-console
+            console.log(`               ${t.description}\n`);
+        }
+    });
+    agent
+        .command('new')
+        .description('Scaffold an Agent OS / DNA project (bare | agent-os | skillgate). DNA = contract; app tools = implementation.')
+        .argument('<name>', 'Project directory / package name')
+        .option('-t, --template <id>', 'Template: bare | agent-os | skillgate', 'agent-os')
+        .option('-d, --dest <dir>', 'Parent directory', '.')
+        .option('-f, --force', 'Allow non-empty destination')
+        .option('--json', 'Print machine-readable result')
+        .action((name, opts) => {
+        try {
+            const destDir = path.resolve(process.cwd(), opts.dest, name);
+            const result = (0, agent_templates_1.scaffoldAgentProject)({
+                name,
+                destDir,
+                template: opts.template,
+                force: opts.force,
+            });
+            const payload = {
+                ok: true,
+                action: 'agent-new',
+                ...result,
+                next: [
+                    `cd ${path.relative(process.cwd(), result.path) || '.'}`,
+                    result.template === 'bare'
+                        ? 'npx hazel agent run dna/agent.marketplace.json "hello"'
+                        : 'npm install && npm run dev',
+                    'npx hazel store publish dna/agent.marketplace.json',
+                ],
+            };
+            // eslint-disable-next-line no-console
+            console.log(opts.json
+                ? JSON.stringify(payload, null, 2)
+                : [
+                    `✓ Created Agent OS project (${result.template})`,
+                    `  ${result.path}`,
+                    `  files: ${result.files.length}`,
+                    '',
+                    'Next:',
+                    ...payload.next.map((l) => `  ${l}`),
+                    '',
+                    'Note: `hazel agent run` on DNA uses stub tools. Use the app (`npm run dev`) for real @Tool / Skillgate handlers.',
+                ].join('\n'));
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e instanceof Error ? e.message : e);
+            process.exitCode = 1;
+        }
+    });
     agent
         .command('install')
         .description('Validate a .dna / marketplace JSON package and print install plan')
@@ -66,7 +139,7 @@ function registerAgentCommand(program) {
                 agent: pkg.dna.name,
                 tools: pkg.dna.tools.map((t) => t.name),
                 hasPolicies: Boolean(pkg.dna.policies?.length),
-                note: 'Call runtime.installAgentPackage(path) in your app to hot-reload',
+                note: 'Validate only. Use hazel store install to materialize into .hazel/agents; call runtime.installAgentPackage(path) to hot-reload',
             }, null, 2));
             if (opts.out) {
                 const outPath = path.join(opts.out, `${pkg.dna.name}.marketplace.json`);
@@ -445,4 +518,297 @@ function registerAgentCommand(program) {
         .action(async (runId, opts) => {
         await resumeAction(runId, { ...opts, approve: true });
     });
+    agent
+        .command('apply')
+        .description('Apply declarative Agent OS platform resources (Definition / Deployment / Run)')
+        .requiredOption('-f, --file <path>', 'Manifest file (JSON or YAML)')
+        .option('--store <path>', 'Platform resource store path', DEFAULT_PLATFORM_STORE)
+        .option('--registry <path>', 'Local package registry root for packageRef resolution')
+        .option('--project <path>', 'Project root for .hazel/agents packageRef resolution', '.')
+        .action(async (opts) => {
+        try {
+            const { createLocalPlatform, defaultRegistryRoot, parsePlatformDocuments } = await Promise.resolve().then(() => __importStar(require('@hazeljs/agent')));
+            const text = fs.readFileSync(path.resolve(opts.file), 'utf8');
+            const docs = parsePlatformDocuments(text);
+            const projectRoot = path.resolve(opts.project);
+            const platform = createLocalPlatform({
+                storePath: path.resolve(opts.store),
+                projectRoot,
+                registryRoot: opts.registry ? path.resolve(opts.registry) : defaultRegistryRoot(),
+            });
+            const results = [];
+            for (const doc of docs) {
+                const result = await platform.reconciler.applyResource(doc);
+                results.push({
+                    kind: result.resource.kind,
+                    name: result.resource.metadata.name,
+                    namespace: result.resource.metadata.namespace ?? 'default',
+                    generation: result.resource.metadata.generation,
+                    ready: result.ready,
+                    message: result.message,
+                    conditions: result.resource.status?.conditions,
+                    resolved: result.resource.status?.backend,
+                });
+            }
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify({ applied: results.length, results }, null, 2));
+            if (results.some((r) => !r.ready))
+                process.exitCode = 1;
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e instanceof Error ? e.message : e);
+            process.exitCode = 1;
+        }
+    });
+    agent
+        .command('get')
+        .description('List or get platform resources from the local store')
+        .argument('[type]', 'Resource type (e.g. agentdefinitions, agentdeployments)')
+        .argument('[name]', 'Resource name')
+        .option('--store <path>', 'Platform resource store path', DEFAULT_PLATFORM_STORE)
+        .option('-n, --namespace <ns>', 'Namespace filter', 'default')
+        .option('--all-namespaces', 'List across namespaces')
+        .option('--project <path>', 'Project root (durable run correlation)', '.')
+        .option('--summary', 'Print secret-safe summaries instead of full resources')
+        .action(async (type, name, opts) => {
+        try {
+            const { createLocalPlatform, parseResourceTypeArg, summarizeResource } = await Promise.resolve().then(() => __importStar(require('@hazeljs/agent')));
+            const platform = createLocalPlatform({
+                storePath: path.resolve(opts.store),
+                projectRoot: path.resolve(opts.project),
+                actor: 'cli',
+            });
+            let kind;
+            let resourceName = name;
+            if (type) {
+                const parsed = parseResourceTypeArg(name ? `${type}/${name}` : type);
+                kind = parsed.kind;
+                resourceName = parsed.name ?? name;
+                if (parsed.namespace && !opts.allNamespaces) {
+                    opts.namespace = parsed.namespace;
+                }
+            }
+            if (kind && resourceName) {
+                const found = platform.repo.get(kind, resourceName, opts.namespace);
+                if (!found) {
+                    // eslint-disable-next-line no-console
+                    console.error(`Not found: ${opts.namespace}/${kind}/${resourceName}`);
+                    process.exitCode = 1;
+                    return;
+                }
+                // eslint-disable-next-line no-console
+                console.log(JSON.stringify(opts.summary ? summarizeResource(found) : found, null, 2));
+                return;
+            }
+            const items = platform.repo.list({
+                kind,
+                namespace: opts.allNamespaces ? undefined : opts.namespace,
+            });
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify({
+                items: opts.summary
+                    ? items.map(summarizeResource)
+                    : items.map((r) => ({
+                        kind: r.kind,
+                        name: r.metadata.name,
+                        namespace: r.metadata.namespace ?? 'default',
+                        generation: r.metadata.generation,
+                        ready: r.status?.conditions?.find((c) => c.type === 'Ready')?.status,
+                    })),
+            }, null, 2));
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e instanceof Error ? e.message : e);
+            process.exitCode = 1;
+        }
+    });
+    agent
+        .command('describe')
+        .description('Describe a platform resource (spec, status, conditions)')
+        .argument('<resource>', 'kind/name or namespace/kind/name')
+        .option('--store <path>', 'Platform resource store path', DEFAULT_PLATFORM_STORE)
+        .option('--project <path>', 'Project root (re-correlate durable runs on describe)', '.')
+        .option('--refresh', 'Re-reconcile before describe (refresh durable correlation)')
+        .action(async (resource, opts) => {
+        try {
+            const { createLocalPlatform, parseResourceTypeArg } = await Promise.resolve().then(() => __importStar(require('@hazeljs/agent')));
+            const parsed = parseResourceTypeArg(resource);
+            if (!parsed.name) {
+                throw new Error('describe requires kind/name (e.g. agentdeployment/support)');
+            }
+            const platform = createLocalPlatform({
+                storePath: path.resolve(opts.store),
+                projectRoot: path.resolve(opts.project),
+            });
+            const ns = parsed.namespace ?? 'default';
+            if (opts.refresh) {
+                if (parsed.kind === 'AgentDeployment') {
+                    await platform.reconciler.reconcileDeployment(parsed.name, ns);
+                }
+                else if (parsed.kind === 'AgentRun') {
+                    await platform.reconciler.reconcileRun(parsed.name, ns);
+                }
+            }
+            const found = platform.repo.get(parsed.kind, parsed.name, ns);
+            if (!found) {
+                // eslint-disable-next-line no-console
+                console.error(`Not found: ${ns}/${parsed.kind}/${parsed.name}`);
+                process.exitCode = 1;
+                return;
+            }
+            const { summarizeResource } = await Promise.resolve().then(() => __importStar(require('@hazeljs/agent')));
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify({
+                resource: found,
+                summary: summarizeResource(found),
+            }, null, 2));
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e instanceof Error ? e.message : e);
+            process.exitCode = 1;
+        }
+    });
+    agent
+        .command('delete')
+        .description('Delete a platform resource (deployments clean up the local backend)')
+        .argument('<resource>', 'kind/name or namespace/kind/name')
+        .option('--store <path>', 'Platform resource store path', DEFAULT_PLATFORM_STORE)
+        .action(async (resource, opts) => {
+        try {
+            const { createLocalPlatform, parseResourceTypeArg } = await Promise.resolve().then(() => __importStar(require('@hazeljs/agent')));
+            const parsed = parseResourceTypeArg(resource);
+            if (!parsed.name) {
+                throw new Error('delete requires kind/name (e.g. agentdeployment/support)');
+            }
+            const platform = createLocalPlatform({
+                storePath: path.resolve(opts.store),
+                projectRoot: process.cwd(),
+            });
+            const result = await platform.reconciler.deleteResource({
+                kind: parsed.kind,
+                name: parsed.name,
+                namespace: parsed.namespace ?? 'default',
+            });
+            // FileResourceRepository auto-persists; keep save() for compatibility
+            platform.save();
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify({
+                deleted: result.deleted,
+                kind: parsed.kind,
+                name: parsed.name,
+                namespace: parsed.namespace ?? 'default',
+                backendMessage: result.backendMessage,
+            }, null, 2));
+            if (!result.deleted)
+                process.exitCode = 1;
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e instanceof Error ? e.message : e);
+            process.exitCode = 1;
+        }
+    });
+    agent
+        .command('reconcile')
+        .description('Reconcile all AgentDeployments / AgentRuns in the local platform store (control-plane loop)')
+        .option('--store <path>', 'Platform resource store path', DEFAULT_PLATFORM_STORE)
+        .option('--project <path>', 'Project root for packageRef / durable run correlation', '.')
+        .option('--registry <path>', 'Local package registry root for packageRef resolution')
+        .option('-n, --namespace <ns>', 'Limit to one namespace')
+        .option('--watch', 'Keep reconciling on an interval until interrupted')
+        .option('--interval <seconds>', 'Watch interval in seconds (default 5)', '5')
+        .action(async (opts) => {
+        try {
+            const { createLocalPlatform, defaultRegistryRoot, watchLocalPlatform } = await Promise.resolve().then(() => __importStar(require('@hazeljs/agent')));
+            const projectRoot = path.resolve(opts.project);
+            const platform = createLocalPlatform({
+                storePath: path.resolve(opts.store),
+                projectRoot,
+                registryRoot: opts.registry ? path.resolve(opts.registry) : defaultRegistryRoot(),
+                actor: 'cli',
+            });
+            const namespace = opts.namespace;
+            const printTick = (result, tick) => {
+                // eslint-disable-next-line no-console
+                console.log(JSON.stringify({
+                    tick: tick ?? 1,
+                    ready: result.ready,
+                    notReady: result.notReady,
+                    errors: result.errors,
+                    items: result.results.map((r) => ({
+                        kind: r.resource.kind,
+                        name: r.resource.metadata.name,
+                        namespace: r.resource.metadata.namespace ?? 'default',
+                        ready: r.ready,
+                        message: r.message,
+                    })),
+                }, null, 2));
+            };
+            if (!opts.watch) {
+                const result = await platform.reconcileAll({ namespace });
+                printTick(result);
+                if (result.notReady > 0 || result.errors.length > 0)
+                    process.exitCode = 1;
+                return;
+            }
+            const seconds = Math.max(1, Number(opts.interval) || 5);
+            const ac = new AbortController();
+            const onSig = () => ac.abort();
+            process.on('SIGINT', onSig);
+            process.on('SIGTERM', onSig);
+            // eslint-disable-next-line no-console
+            console.error(`Watching every ${seconds}s (Ctrl+C to stop)…`);
+            await watchLocalPlatform(platform, {
+                namespace,
+                intervalMs: seconds * 1000,
+                signal: ac.signal,
+                onTick: async (result, tick) => {
+                    printTick(result, tick);
+                },
+            });
+            process.off('SIGINT', onSig);
+            process.off('SIGTERM', onSig);
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e instanceof Error ? e.message : e);
+            process.exitCode = 1;
+        }
+    });
+    agent
+        .command('events')
+        .description('List platform control-plane events (audit log; no secrets)')
+        .option('--store <path>', 'Platform resource store path', DEFAULT_PLATFORM_STORE)
+        .option('--events <path>', 'Events JSONL path (default: beside store)')
+        .option('--type <type>', 'Filter by event type')
+        .option('--kind <kind>', 'Filter by resource kind')
+        .option('--limit <n>', 'Max events (most recent)', '50')
+        .action(async (opts) => {
+        try {
+            const { createLocalPlatform } = await Promise.resolve().then(() => __importStar(require('@hazeljs/agent')));
+            const storePath = path.resolve(opts.store);
+            const platform = createLocalPlatform({
+                storePath,
+                eventsPath: opts.events
+                    ? path.resolve(opts.events)
+                    : path.join(path.dirname(storePath), 'events.jsonl'),
+                actor: 'cli',
+            });
+            const items = platform.events.list({
+                type: opts.type,
+                kind: opts.kind,
+                limit: Number(opts.limit) || 50,
+            });
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify({ items }, null, 2));
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e instanceof Error ? e.message : e);
+            process.exitCode = 1;
+        }
+    });
 }

package/dist/commands/agent.test.js

@@ -1,14 +1,104 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
 const commander_1 = require("commander");
 const agent_1 = require("./agent");
-describe('registerAgentCommand (AOS-011)', () => {
-    it('registers run, logs, and doctor subcommands', () => {
+const agent_templates_1 = require("./agent-templates");
+describe('registerAgentCommand (AOS-011 + templates)', () => {
+    it('registers run, logs, doctor, new, and templates subcommands', () => {
         const program = new commander_1.Command();
         (0, agent_1.registerAgentCommand)(program);
         const agent = program.commands.find((c) => c.name() === 'agent');
         expect(agent).toBeDefined();
         const names = agent.commands.map((c) => c.name());
-        expect(names).toEqual(expect.arrayContaining(['install', 'dna', 'run', 'logs', 'doctor', 'runs']));
+        expect(names).toEqual(expect.arrayContaining([
+            'install',
+            'dna',
+            'run',
+            'logs',
+            'doctor',
+            'runs',
+            'new',
+            'templates',
+            'apply',
+            'get',
+            'describe',
+            'delete',
+            'events',
+        ]));
+    });
+});
+describe('agent templates scaffold', () => {
+    let tmp;
+    beforeEach(() => {
+        tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'hazel-agent-new-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    });
+    it('lists three templates', () => {
+        expect((0, agent_templates_1.listAgentTemplates)().map((t) => t.id)).toEqual(['bare', 'agent-os', 'skillgate']);
+    });
+    it('scaffolds bare DNA package', () => {
+        const dest = path.join(tmp, 'bare-demo');
+        const result = (0, agent_templates_1.scaffoldAgentProject)({ name: 'bare-demo', destDir: dest, template: 'bare' });
+        expect(result.files).toContain('dna/agent.marketplace.json');
+        const pkg = JSON.parse(fs.readFileSync(path.join(dest, 'dna/agent.marketplace.json'), 'utf8'));
+        expect(pkg.dna.format).toBe('hazeljs.agent.dna');
+        expect(pkg.dna.name).toBeTruthy();
+    });
+    it('scaffolds agent-os with real tool source', () => {
+        const dest = path.join(tmp, 'os-demo');
+        (0, agent_templates_1.scaffoldAgentProject)({ name: 'os-demo', destDir: dest, template: 'agent-os' });
+        expect(fs.existsSync(path.join(dest, 'src/support.agent.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(dest, 'src/main.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(dest, 'dna/agent.marketplace.json'))).toBe(true);
+    });
+    it('scaffolds skillgate with openapi sample', () => {
+        const dest = path.join(tmp, 'sg-demo');
+        (0, agent_templates_1.scaffoldAgentProject)({ name: 'sg-demo', destDir: dest, template: 'skillgate' });
+        expect(fs.existsSync(path.join(dest, 'openapi/sample.openapi.json'))).toBe(true);
+        expect(fs.existsSync(path.join(dest, 'src/report.ts'))).toBe(true);
+    });
+    it('refuses non-empty dest without force', () => {
+        const dest = path.join(tmp, 'taken');
+        fs.mkdirSync(dest);
+        fs.writeFileSync(path.join(dest, 'x.txt'), 'x');
+        expect(() => (0, agent_templates_1.scaffoldAgentProject)({ name: 'taken', destDir: dest, template: 'bare' })).toThrow(/not empty/);
     });
 });

package/dist/commands/gatekeeper.d.ts

@@ -0,0 +1,7 @@
+import { Command } from 'commander';
+/**
+ * `hazel gatekeeper validate --config agent-gatekeeper.yaml`
+ * `hazel gatekeeper simulate --agent refund-agent --tool stripe.refund --input input.json`
+ * `hazel gatekeeper explain --invocation invocation.json`
+ */
+export declare function registerGatekeeperCommand(program: Command): void;