@aion0/forge 0.10.6 → 0.10.17

package/lib/__tests__/foreach-snapshot.test.ts

@@ -1,112 +0,0 @@
-/**
- * Step-5 verification: snapshotIteration captures node states + correctly
- * advances the iterations[] history. (Full checkPipelineCompletion has
- * filesystem + scheduling side effects — exercised end-to-end in Step 7.)
- *
- * Run:  npx tsx lib/__tests__/foreach-snapshot.test.ts
- */
-
-import { snapshotIteration } from '../pipeline';
-
-let passed = 0, failed = 0;
-function check(name: string, fn: () => void) {
-  try { fn(); console.log(`  ✓ ${name}`); passed++; }
-  catch (e) { console.log(`  ✗ ${name}\n    ${(e as Error).message}`); failed++; }
-}
-
-function makePipeline(items: unknown[], currentIndex = 0): any {
-  return {
-    id: 'test123',
-    workflowName: 'test',
-    status: 'running',
-    input: {},
-    vars: {},
-    nodes: {
-      a: { status: 'done', outputs: { x: '1' } },
-      b: { status: 'done', outputs: { y: '2' }, error: undefined },
-    },
-    nodeOrder: ['a', 'b'],
-    createdAt: '2026-01-01T00:00:00.000Z',
-    forEach: {
-      items,
-      currentIndex,
-      total: items.length,
-      asName: 'item',
-      onFailure: 'continue',
-      iterations: [],
-    },
-  };
-}
-
-console.log('snapshotIteration tests');
-
-check('snapshot captures all-done nodes with status="done"', () => {
-  const p = makePipeline([1, 2, 3]);
-  snapshotIteration(p, false);
-  if (p.forEach.iterations.length !== 1) throw new Error('iterations length wrong');
-  const iter = p.forEach.iterations[0];
-  if (iter.status !== 'done') throw new Error(`status wrong: ${iter.status}`);
-  if (iter.index !== 0) throw new Error('index wrong');
-  if (iter.nodes.a.status !== 'done') throw new Error('node a status wrong');
-  if (iter.nodes.a.outputs.x !== '1') throw new Error('node a output not preserved');
-});
-
-check('snapshot captures failed iter with status="failed"', () => {
-  const p = makePipeline([1, 2]);
-  p.nodes.b.status = 'failed';
-  p.nodes.b.error = 'boom';
-  snapshotIteration(p, true);
-  const iter = p.forEach.iterations[0];
-  if (iter.status !== 'failed') throw new Error(`status wrong: ${iter.status}`);
-  if (iter.nodes.b.error !== 'boom') throw new Error('error not preserved');
-});
-
-check('startedAt = createdAt for first iter', () => {
-  const p = makePipeline([1, 2]);
-  snapshotIteration(p, false);
-  if (p.forEach.iterations[0].startedAt !== p.createdAt) throw new Error('first startedAt should = createdAt');
-});
-
-check('startedAt = previous completedAt for subsequent iters', () => {
-  const p = makePipeline([1, 2]);
-  snapshotIteration(p, false);
-  const firstCompleted = p.forEach.iterations[0].completedAt;
-  p.forEach.currentIndex = 1;
-  snapshotIteration(p, false);
-  if (p.forEach.iterations[1].startedAt !== firstCompleted) {
-    throw new Error('second iter startedAt should chain from prev completedAt');
-  }
-});
-
-check('outputs are deep-copied (mutation safety)', () => {
-  const p = makePipeline([1]);
-  snapshotIteration(p, false);
-  const iter = p.forEach.iterations[0];
-  // Mutate live node — snapshot should NOT change
-  p.nodes.a.outputs.x = 'MUTATED';
-  if (iter.nodes.a.outputs.x !== '1') throw new Error('snapshot was mutated; need defensive copy');
-});
-
-check('multiple iterations accumulate', () => {
-  const p = makePipeline([1, 2, 3]);
-  snapshotIteration(p, false);
-  p.forEach.currentIndex = 1;
-  snapshotIteration(p, false);
-  p.forEach.currentIndex = 2;
-  snapshotIteration(p, true);
-  if (p.forEach.iterations.length !== 3) throw new Error('expected 3 iters');
-  if (p.forEach.iterations[2].status !== 'failed') throw new Error('iter 3 should be failed');
-  if (p.forEach.iterations[0].index !== 0) throw new Error('iter 0 index wrong');
-  if (p.forEach.iterations[1].index !== 1) throw new Error('iter 1 index wrong');
-  if (p.forEach.iterations[2].index !== 2) throw new Error('iter 2 index wrong');
-});
-
-check('no-op when pipeline.forEach undefined', () => {
-  const p: any = { id: 'x', nodes: {}, createdAt: '2026-01-01' };
-  snapshotIteration(p, false);
-  // Should not throw, should not add anything
-  if (p.forEach !== undefined) throw new Error('should leave forEach undefined');
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed === 0 ? 0 : 1);

package/lib/__tests__/foreach-source.test.ts

@@ -1,105 +0,0 @@
-/**
- * Step-4 verification: resolveForEachSource resolves + splits items.
- * Run:  npx tsx lib/__tests__/foreach-source.test.ts
- */
-
-import { resolveForEachSource } from '../pipeline';
-
-let passed = 0, failed = 0;
-function check(name: string, fn: () => void) {
-  try { fn(); console.log(`  ✓ ${name}`); passed++; }
-  catch (e) { console.log(`  ✗ ${name}\n    ${(e as Error).message}`); failed++; }
-}
-function eqArr(a: unknown[], b: unknown[], label = '') {
-  if (a.length !== b.length || a.some((v, i) => v !== b[i])) {
-    throw new Error(`${label}: expected ${JSON.stringify(b)}, got ${JSON.stringify(a)}`);
-  }
-}
-
-console.log('resolveForEachSource tests');
-
-check('string source via {{input.x}} template, default split=","', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}' },
-    { ids: '111,222,333' },
-    {},
-  );
-  eqArr(items, ['111', '222', '333']);
-});
-
-check('string source with whitespace around commas — trimmed', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}' },
-    { ids: ' 111 ,222 , 333  ' },
-    {},
-  );
-  eqArr(items, ['111', '222', '333']);
-});
-
-check('string source with empty entries dropped', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}' },
-    { ids: '111,,222, ,333,' },
-    {},
-  );
-  eqArr(items, ['111', '222', '333']);
-});
-
-check('empty input.ids → empty array', () => {
-  const items = resolveForEachSource({ source: '{{input.ids}}' }, { ids: '' }, {});
-  eqArr(items, []);
-});
-
-check('input missing → empty string template → empty array', () => {
-  const items = resolveForEachSource({ source: '{{input.missing}}' }, {}, {});
-  eqArr(items, []);
-});
-
-check('custom split: ";"', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}', split: ';' },
-    { ids: '111;222;333' },
-    {},
-  );
-  eqArr(items, ['111', '222', '333']);
-});
-
-check('array literal source — used as-is', () => {
-  const items = resolveForEachSource(
-    { source: ['a', 'b', 'c'] },
-    {},
-    {},
-  );
-  eqArr(items, ['a', 'b', 'c']);
-});
-
-check('array literal with objects — preserved', () => {
-  const items = resolveForEachSource(
-    { source: [{ iid: 1 }, { iid: 2 }] },
-    {},
-    {},
-  );
-  if (items.length !== 2) throw new Error('length wrong');
-  if ((items[0] as any).iid !== 1) throw new Error('first item wrong');
-});
-
-check('vars source resolves', () => {
-  const items = resolveForEachSource(
-    { source: '{{vars.list}}' },
-    {},
-    { list: 'a,b,c' },
-  );
-  eqArr(items, ['a', 'b', 'c']);
-});
-
-check('literal string with no template, just split', () => {
-  const items = resolveForEachSource(
-    { source: 'foo,bar' },
-    {},
-    {},
-  );
-  eqArr(items, ['foo', 'bar']);
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed === 0 ? 0 : 1);

package/lib/__tests__/foreach-template.test.ts

@@ -1,112 +0,0 @@
-/**
- * Step-3 verification: resolveTemplate handles for_each context.
- * Run:  npx tsx lib/__tests__/foreach-template.test.ts
- */
-
-import { resolveTemplate } from '../pipeline';
-
-let passed = 0;
-let failed = 0;
-function check(name: string, fn: () => void) {
-  try { fn(); console.log(`  ✓ ${name}`); passed++; }
-  catch (e) { console.log(`  ✗ ${name}\n    ${(e as Error).message}`); failed++; }
-}
-function eq(actual: string, expected: string, label = '') {
-  if (actual !== expected) {
-    throw new Error(`${label}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
-  }
-}
-
-const baseCtx = { input: {}, vars: {}, nodes: {} };
-
-console.log('resolveTemplate + for_each tests');
-
-check('no forEach in ctx — {{item}} is literal passthrough', () => {
-  eq(resolveTemplate('hello {{item}}', baseCtx), 'hello {{item}}');
-});
-
-check('scalar item: {{<as>}} substitutes', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'bug_id', item: 1213844, index: 0, total: 3 } };
-  eq(resolveTemplate('Fix bug {{bug_id}} now', ctx), 'Fix bug 1213844 now');
-});
-
-check('string item: {{<as>}} preserves string', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'name', item: 'alice', index: 0, total: 1 } };
-  eq(resolveTemplate('hi {{name}}', ctx), 'hi alice');
-});
-
-check('object item: {{<as>.field}} dotted access', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'mr', item: { iid: 42, title: 'fix x' }, index: 0, total: 1 } };
-  eq(resolveTemplate('MR !{{mr.iid}}: {{mr.title}}', ctx), 'MR !42: fix x');
-});
-
-check('object item: missing field → empty string', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'mr', item: { iid: 42 }, index: 0, total: 1 } };
-  eq(resolveTemplate('author=@{{mr.author}}', ctx), 'author=@');
-});
-
-check('object item: {{<as>}} alone → JSON', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'mr', item: { iid: 42, t: 'x' }, index: 0, total: 1 } };
-  eq(resolveTemplate('raw={{mr}}', ctx), 'raw={"iid":42,"t":"x"}');
-});
-
-check('{{loop.index}} + {{loop.total}}', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'item', item: 'x', index: 2, total: 5 } };
-  eq(resolveTemplate('Step {{loop.index}} of {{loop.total}}', ctx), 'Step 2 of 5');
-});
-
-check('shellMode escapes scalar item', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'name', item: "o'brien", index: 0, total: 1 } };
-  // shellEscapeAnsiC: ' → \'
-  const out = resolveTemplate("echo '{{name}}'", ctx, true);
-  if (!out.includes("o\\'brien")) throw new Error(`expected escaped apostrophe, got: ${out}`);
-});
-
-check('{{raw:<as>}} bypasses shell escape', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'name', item: "o'brien", index: 0, total: 1 } };
-  // raw: keeps verbatim
-  eq(resolveTemplate('{{raw:name}}', ctx, true), "o'brien");
-});
-
-check('input.x still works alongside forEach', () => {
-  const ctx = { input: { proj: 'FortiNAC' }, vars: {}, nodes: {}, forEach: { asName: 'bug_id', item: 1, index: 0, total: 1 } };
-  eq(resolveTemplate('{{input.proj}}/mantis-{{bug_id}}', ctx), 'FortiNAC/mantis-1');
-});
-
-check('nodes.X.outputs.Y still works alongside forEach', () => {
-  const ctx: any = {
-    input: {},
-    vars: {},
-    nodes: { ingest: { status: 'done', outputs: { ctx: 'hello' }, iterations: 1 } },
-    forEach: { asName: 'item', item: 'x', index: 0, total: 1 },
-  };
-  eq(resolveTemplate('{{nodes.ingest.outputs.ctx}}/{{item}}', ctx), 'hello/x');
-});
-
-check('run.tmp_dir still works alongside forEach', () => {
-  const ctx = {
-    ...baseCtx,
-    tmpDir: '/path/.forge/worktrees/pipeline-abc',
-    forEach: { asName: 'bug_id', item: 42, index: 0, total: 1 },
-  };
-  eq(resolveTemplate('{{run.tmp_dir}}/mantis-{{bug_id}}', ctx),
-     '/path/.forge/worktrees/pipeline-abc/mantis-42');
-});
-
-check('forEach.item = null → empty string', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'x', item: null, index: 0, total: 1 } };
-  eq(resolveTemplate('[{{x}}]', ctx), '[]');
-});
-
-check('forEach.item = false → "false"', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'x', item: false, index: 0, total: 1 } };
-  eq(resolveTemplate('[{{x}}]', ctx), '[false]');
-});
-
-check('loop.index works even when item is undefined-but-asName-set (defensive)', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'item', item: undefined, index: 7, total: 9 } };
-  eq(resolveTemplate('{{loop.index}}/{{loop.total}}', ctx), '7/9');
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed === 0 ? 0 : 1);