@givolt/i3-composer-agent 2.3.1 → 2.3.3

package/scripts/prototype-generation-evidence-test.js

@@ -0,0 +1,10 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs'),os=require('node:os'),path=require('node:path');
+const install=path.join(__dirname,'lib/installation.js');const skills=fs.existsSync(install)?require(install).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills');
+const script=path.join(skills,'i3-ui-prototype/scripts/generation-evidence.cjs');
+function fixture(t){const directory=fs.mkdtempSync(path.join(os.tmpdir(),'i3-generation-evidence-'));t.after(()=>fs.rmSync(directory,{recursive:true,force:true}));fs.mkdirSync(path.join(directory,'app/src'),{recursive:true});fs.writeFileSync(path.join(directory,'app/src/Actual.vue'),'<template><a-tree /></template>');return directory;}
+const generation={bindings:[{id:'items/tree/hierarchy',capabilityId:'hierarchy'}],scenarios:[{id:'generation/items/tree/hierarchy/expand',bindingId:'items/tree/hierarchy'}]};
+test('each capability maps to implementation and its exact scenarios before acceptance',t=>{const lib=require(script),dir=fixture(t),fixed=lib.initialize(generation);assert.equal(lib.validateImplementation(dir,generation,fixed).status,'pending');assert.throws(()=>lib.validateImplementation(dir,generation,fixed,{complete:true}),/pending/i);const item=fixed.bindings[0];item.status='implemented';item.components=['Tree'];item.files=[{path:'app/src/Actual.vue',locator:'a-tree'}];assert.equal(lib.validateImplementation(dir,generation,fixed,{complete:true}).status,'implemented');item.scenarioIds=[];assert.throws(()=>lib.validateImplementation(dir,generation,fixed),/scenario/i);});
+test('deleting a binding, pointing to absent code, or using input documents cannot pass',t=>{const lib=require(script),dir=fixture(t),fixed=lib.initialize(generation);fixed.bindings=[];assert.throws(()=>lib.validateImplementation(dir,generation,fixed),/binding/i);fixed.bindings=lib.initialize(generation).bindings;Object.assign(fixed.bindings[0],{status:'implemented',components:['Tree'],files:[{path:'inputs/generation.json',locator:'Tree'}]});assert.throws(()=>lib.validateImplementation(dir,generation,fixed),/implementation|source/i);fixed.bindings[0].files[0].path='app/src/Missing.vue';assert.throws(()=>lib.validateImplementation(dir,generation,fixed),/ENOENT|Missing/);});
+test('browser observations need every scenario, actual actions and immutable evidence bytes',t=>{const lib=require(script),dir=fixture(t);assert.throws(()=>lib.validateObservations(dir,generation,{}),/observation/i);fs.mkdirSync(path.join(dir,'qa'));fs.writeFileSync(path.join(dir,'qa/observation.txt'),'Synthetic test evidence, never a browser result.');const hash=require('node:crypto').createHash('sha256').update(fs.readFileSync(path.join(dir,'qa/observation.txt'))).digest('hex');const report={generationObservations:[{scenarioId:generation.scenarios[0].id,bindingId:generation.bindings[0].id,status:'passed',steps:[{action:'fixture action',target:'fixture tree',observed:'fixture result'}],toolCallIds:['fixture-call'],evidence:[{path:'qa/observation.txt',sha256:hash}]}]};assert.equal(lib.validateObservations(dir,generation,report).invocationVerified,false);report.generationObservations[0].steps=[];assert.throws(()=>lib.validateObservations(dir,generation,report),/step/i);report.generationObservations[0].steps=[{action:'fixture',target:'fixture',observed:'fixture'}];fs.appendFileSync(path.join(dir,'qa/observation.txt'),'changed');assert.throws(()=>lib.validateObservations(dir,generation,report),/evidence/i);});
+test('framework mapping covers all semantic capabilities without device sample assumptions',()=>{const lib=require(script),catalog=require(path.join(skills,'i3-ui-prototype/assets/capabilities/generation.json')),map=lib.framework();assert.deepEqual(Object.keys(map.capabilities).sort(),Object.keys(catalog.capabilities).sort());assert.ok(!JSON.stringify(map).includes('useDevices'));assert.ok(!JSON.stringify(map).includes('21 deterministic'));});

package/scripts/prototype-generation-native-test.js

@@ -0,0 +1,78 @@
+'use strict';
+const test = require('node:test'), assert = require('node:assert/strict'), fs = require('node:fs'), os = require('node:os'), path = require('node:path');
+const install = path.join(__dirname, 'lib/installation.js');
+const skills = fs.existsSync(install) ? require(install).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
+const root = path.join(skills, 'i3-ui-prototype'), templates = require(path.join(root, 'scripts/template-contract.cjs')), native = require(path.join(root, 'scripts/native-pilot-lib.cjs'));
+const read = file => JSON.parse(fs.readFileSync(file));
+function fixture(t) {
+  const project = fs.mkdtempSync(path.join(os.tmpdir(), 'i3-generation-native-')); t.after(() => fs.rmSync(project, { recursive: true, force: true }));
+  const scope = { schemaVersion: 3, moduleIds: ['assets'], title: '资产', pages: [{ id: 'assets', title: '资产台账', referencePage: 'models-page', regions: [{ id: 'list', mode: 'content', pattern: 'tree-list' }] }], requirements: [{ id: 'A-01', text: '资产层级台账', pages: ['assets'], source: { type: 'prd', reference: 'fixture/A-01', statement: 'Synthetic source fixture only, not acceptance.' } }], generation: { presentation: { layout: 'mixed', style: 'soft', density: 'compact' } } };
+  const file = path.join(project, 'scope.json');fs.writeFileSync(file, JSON.stringify(scope));
+  return { project, scope, file, create: () => native.createPrototype({ project, id: 'assets', scope: file, expertMode: 'template' }) };
+}
+test('schema v3 creation freezes pattern contracts, customer choices and per-region acceptance', t => {
+  const { create, project } = fixture(t), result = create(), inputs = path.join(result.directory, 'inputs');
+  assert.equal(native.inspect(result.directory).status, 'passed');
+  const fixed = read(path.join(inputs, 'generation.json')), config = read(path.join(result.directory, 'app/public/prototype-config.json'));
+  assert.deepEqual(config.presentation, { layout: 'mixed', style: 'soft', density: 'compact' });
+  assert.equal(fixed.pages[0].regions[0].pattern, 'tree-list');
+  assert.ok(read(path.join(inputs, 'acceptance.json')).requiredScenarios.some(id => id.includes('/hierarchy/')));
+  assert.deepEqual(read(path.join(project, 'prototypes/index.json')).prototypes[0].appliesTo, ['assets']);
+  assert.equal(read(path.join(result.directory, 'prototype.json')).business.status, 'needs-adaptation');
+  assert.ok(fs.existsSync(path.join(result.directory, 'app/src/PrototypeShell.vue')));
+});
+test('generation constraints cannot be removed together with their acceptance IDs', t => {
+  const { create } = fixture(t), dir = create().directory, file = path.join(dir, 'inputs/generation.json');
+  const fixed = read(file);fixed.bindings = fixed.bindings.filter(item => item.capabilityId !== 'hierarchy');fs.writeFileSync(file, JSON.stringify(fixed));
+  const candidate = native.manifest(dir);
+  assert.throws(() => native.revise(dir, { revision: 'r002', expectedRevision: candidate.revision, expectedDigest: candidate.digest, acceptInputs: true }), /generation|contract/i);
+});
+test('unsupported and planned native templates are rejected rather than falling back to enterprise', t => {
+  fixture(t);
+  assert.throws(() => templates.loadBundledTemplate('ai-workbench'), /available|Unsupported|planned/);
+  assert.throws(() => templates.loadBundledTemplate('../outside'), /identifier|template/i);
+});
+test('legacy sourced scopes keep the original input contract and no new presentation is forced', t => {
+  const { scope, file, create } = fixture(t); scope.schemaVersion = 2; delete scope.generation; delete scope.pages[0].regions[0].pattern;
+  fs.writeFileSync(file, JSON.stringify(scope)); const dir = create().directory;
+  assert.equal(fs.existsSync(path.join(dir, 'inputs/generation.json')), false);
+  assert.equal(read(path.join(dir, 'app/public/prototype-config.json')).presentation, undefined);
+  assert.equal(native.inspect(dir).status, 'passed');
+});
+test('another registered content template uses its own structure and defaults without a core ID branch', t => {
+  const { project, scope, file } = fixture(t), pack = path.join(project, 'template-pack'), directory = path.join(pack, 'alternate');fs.mkdirSync(directory, { recursive: true });
+  fs.writeFileSync(path.join(pack, 'catalog.json'), JSON.stringify({ defaultTemplate: 'alternate', templates: [{ id: 'alternate', availability: 'available', contentRoot: 'alternate' }] }));
+  fs.writeFileSync(path.join(directory, 'template.json'), JSON.stringify({ id: 'alternate', version: '1.0.0', kind: 'content-reference', entry: 'index.html', definition: 'capability-definition.json' }));
+  fs.copyFileSync(path.join(root, 'assets/capabilities/management.json'), path.join(directory, 'capability-definition.json'));
+  fs.writeFileSync(path.join(directory, 'index.html'), '<script id="prototype-offline-routes">[{"path":"/items","component":"./Items.js"}]</script>\n<template data-source="reference/Items.html">\n<main><h1>另一套内容</h1><template data-component="Button" data-on-click="view">查看</template></main>\n</template>\n');
+  fs.writeFileSync(path.join(directory, 'component-inventory.json'), JSON.stringify({ schemaVersion: 1, components: { Button: { kind: 'framework', capabilities: ['interaction'] } } }));
+  const meta = read(path.join(root, 'assets/templates/enterprise-admin/generation.json'));meta.templateId = 'alternate';meta.shell = null;meta.defaults = { layout: 'topbar', style: 'minimal', density: 'comfortable' };meta.patterns = ['content'];
+  fs.writeFileSync(path.join(directory, 'generation.json'), JSON.stringify(meta));templates.syncTemplate(directory);
+  assert.equal(templates.loadBundledTemplate('alternate', { templatesRoot: pack }).id, 'alternate');
+  scope.pages[0].referencePage = 'items';scope.pages[0].regions[0].pattern = 'content';delete scope.generation.presentation;fs.writeFileSync(file, JSON.stringify(scope));
+  const result = native.createPrototype({ project, id: 'alternate-result', scope: file, templateRoot: directory, expertMode: 'template' });
+  assert.equal(read(path.join(result.directory, 'prototype.json')).template.id, 'alternate');
+  assert.equal(read(path.join(result.directory, 'inputs/generation.json')).presentation.layout, 'topbar');
+  assert.equal(native.inspect(result.directory).status, 'passed');
+});
+test('marking a scaffold adapted cannot bypass the new implementation acceptance gate',t=>{
+  const {create}=fixture(t),dir=create().directory,file=path.join(dir,'prototype.json'),meta=read(file);meta.business.status='adapted';fs.writeFileSync(file,JSON.stringify(meta));
+  const checked=native.inspect(dir,{acceptance:true});assert.equal(checked.status,'failed');assert.match(checked.errors.join(' '),/Implementation pending/);
+  fs.unlinkSync(path.join(dir,'design-system/implementation.json'));assert.equal(native.inspect(dir).status,'failed');
+});
+test('replan refreshes the complete fixed contract atomically and refuses invalid scope or stale identity',t=>{
+ const {create,scope,file}=fixture(t),dir=create().directory,before=native.manifest(dir);assert.equal(typeof native.replan,'function');
+ scope.generation.presentation.layout='topbar';fs.writeFileSync(file,JSON.stringify(scope));
+ const next=native.replan(dir,{scope:file,revision:'r002',expectedRevision:before.revision,expectedDigest:before.digest});assert.equal(next.revision,'r002');
+ assert.equal(read(path.join(dir,'app/public/prototype-config.json')).presentation.layout,'topbar');assert.ok(fs.readFileSync(path.join(dir,'design-system/MASTER.md'),'utf8').includes('布局 topbar'));assert.equal(native.inspect(dir).status,'passed');
+ const stable=native.manifest(dir);scope.generation.presentation.layout='bad-layout';fs.writeFileSync(file,JSON.stringify(scope));
+ assert.throws(()=>native.replan(dir,{scope:file,revision:'r003',expectedRevision:stable.revision,expectedDigest:stable.digest}),/choice/);assert.equal(native.manifest(dir).digest,stable.digest);
+ assert.throws(()=>native.replan(dir,{scope:file,revision:'r003',expectedRevision:before.revision,expectedDigest:before.digest}),/Stale|changed/);
+});
+test('replan restores fixed bytes if revision admission fails after input writes',t=>{
+ const {create,scope,file}=fixture(t),dir=create().directory,before=native.manifest(dir);scope.generation.presentation.layout='topbar';fs.writeFileSync(file,JSON.stringify(scope));fs.mkdirSync(path.join(dir,'baselines/r002'),{recursive:true});
+ assert.throws(()=>native.replan(dir,{scope:file,revision:'r002',expectedRevision:before.revision,expectedDigest:before.digest}),/frozen/);assert.deepEqual(native.manifest(dir),before);assert.equal(native.inspect(dir).status,'passed');
+});
+test('v3 state keeps recovery compact while exposing pending decisions and exact commands',t=>{
+ const {create}=fixture(t),dir=create().directory,state=native.state(dir,{});assert.equal(state.nextAction,'resolve-generation-decisions');assert.ok(Buffer.byteLength(JSON.stringify(state))<25000);assert.ok(state.commands.replan);assert.ok(state.generation.referenceReview.pendingCount>0);assert.equal(state.scopes.sourceFile,'inputs/scope.json');
+});

package/scripts/prototype-generation-test.js

@@ -0,0 +1,99 @@
+'use strict';
+const test = require('node:test'), assert = require('node:assert/strict'), fs = require('node:fs'), path = require('node:path');
+const install = path.join(__dirname, 'lib/installation.js');
+const skills = fs.existsSync(install) ? require(install).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
+const root = path.join(skills, 'i3-ui-prototype'), templates = require(path.join(root, 'scripts/template-contract.cjs'));
+const generation = require(path.join(root, 'scripts/generation-contract.cjs'));
+function scope(pattern = 'management-list') {
+  return { schemaVersion: 3, moduleIds: ['assets'], pages: [{ id: 'assets', title: '资产', referencePage: 'models-page', regions: [{ id: 'main', mode: 'content', pattern }] }], requirements: [{ id: 'A-01', text: '按实际资产需求适配参考页面', pages: ['assets'], source: { type: 'prd', reference: 'fixture/A-01', statement: 'Synthetic contract fixture; not user or runtime acceptance.' } }], generation: { presentation: { layout: 'mixed', style: 'minimal', density: 'compact' }, decisions: [] } };
+}
+test('selected page patterns derive complete abilities and frozen customer presentation choices', () => {
+  const fixed = generation.compile(templates.loadBundledTemplate(), scope());
+  assert.deepEqual(fixed.presentation, { layout: 'mixed', style: 'minimal', density: 'compact' });
+  for (const capability of ['filter', 'selection', 'pagination', 'bulk', 'columns', 'feedback']) assert.ok(fixed.bindings.some(binding => binding.capabilityId === capability));
+  assert.ok(fixed.scenarios.some(scenario => scenario.id.includes('/columns/')));
+  assert.equal(fixed.bindings.find(binding => binding.capabilityId === 'pagination').parameters.defaultPageSize, 10);
+  assert.ok(fixed.referenceCoverage[0].events.length && fixed.referenceCoverage[0].nodes.length);
+});
+test('tree, tree table, wizard, canvas, permissions and dialogs have distinct required behavior', () => {
+  const snapshot = templates.loadBundledTemplate();
+  for (const [pattern, required] of Object.entries({ 'tree-list': ['hierarchy', 'pagination'], 'tree-table': ['hierarchy', 'columns'], wizard: ['wizard', 'dirty'], workflow: ['canvas', 'dirty'], permissions: ['authorization', 'hierarchy'], 'edit-form': ['edit', 'dialog', 'dirty'], detail: ['detail'] })) {
+    const fixed = generation.compile(snapshot, scope(pattern));
+    for (const capability of required) assert.ok(fixed.bindings.some(binding => binding.capabilityId === capability), `${pattern}/${capability}`);
+  }
+});
+test('unknown choices and deleting a required pattern capability fail instead of weakening the contract', () => {
+  const snapshot = templates.loadBundledTemplate(), input = scope(), fixed = generation.compile(snapshot, input);
+  for (const [key,value] of Object.entries({ layout: 'invented-layout', style: 'invented-style', density: 'invisible' })) {
+    const changed = structuredClone(input); changed.generation.presentation[key] = value;
+    assert.throws(() => generation.compile(snapshot, changed), /Unsupported|choice/);
+  }
+  fixed.bindings = fixed.bindings.filter(binding => binding.capabilityId !== 'columns');
+  assert.throws(() => generation.verify(snapshot, input, fixed), /contract|generation/i);
+  input.generation.decisions = [{ pageId: 'assets', capabilityId: 'columns', decision: 'not-applicable', requirementId: 'A-01', reason: 'Do not test columns' }];
+  assert.throws(() => generation.compile(snapshot, input), /required/i);
+});
+test('reference applicability is explicit and omissions remain pending until sourced decisions exist', () => {
+  const snapshot = templates.loadBundledTemplate(), input = scope(), fixed = generation.compile(snapshot, input);
+  assert.ok(fixed.pendingDecisions.length);
+  input.generation.decisions = fixed.pendingDecisions.map(item => ({ ...item, decision: 'not-applicable', requirementId: 'A-01', reason: 'This fixture intentionally narrows its stated business scope.' }));
+  assert.equal(generation.compile(snapshot, input).pendingDecisions.length, 0);
+  input.generation.decisions[0].reason = '';
+  assert.throws(() => generation.compile(snapshot, input), /reason|source/i);
+});
+test('frozen generation rules remain independent from future global catalog changes', () => {
+  const snapshot = templates.loadBundledTemplate(), input = scope(), fixed = generation.compile(snapshot, input);
+  assert.equal(generation.verify(snapshot, input, fixed).status, 'passed');
+  const changed = structuredClone(input); changed.pages[0].regions[0].pattern = 'tree-list';
+  assert.throws(() => generation.verify(snapshot, changed, fixed), /contract|generation/i);
+});
+test('business fields and actions remain sourced and receive individual acceptance identities', () => {
+  const snapshot = templates.loadBundledTemplate(), input = scope(), region = input.pages[0].regions[0];
+  region.fields = [{ id: 'name', label: '资产名称', kind: 'text', required: true, requirementId: 'A-01' }];
+  region.actions = [{ id: 'disable', label: '停用所选资产', kind: 'state-change', target: 'selected', outcome: '只有所选资产变为停用', requirementId: 'A-01' }];
+  const fixed = generation.compile(snapshot, input);
+  assert.equal(fixed.pages[0].regions[0].fields[0].label, '资产名称');
+  assert.ok(fixed.scenarios.some(item => item.id.endsWith('/action/disable')));
+  region.actions[0].requirementId = 'unknown';
+  assert.throws(() => generation.compile(snapshot, input), /source|requirement/);
+});
+test('unknown parameters and attempts to disable selected behavior fail validation', () => {
+  const snapshot = templates.loadBundledTemplate(), input = scope();
+  input.pages[0].regions[0].parameters = { columns: { enabled: false } };
+  assert.throws(() => generation.compile(snapshot, input), /parameter|Unsupported/i);
+});
+test('navigation groups preserve every declared page once and reject missing or duplicate routes', () => {
+  const snapshot = templates.loadBundledTemplate(), input = scope();
+  input.generation.navigation = [{ id: 'assets-group', title: '资产管理', children: [{ pageId: 'assets' }] }];
+  assert.equal(generation.compile(snapshot, input).navigation[0].children[0].key, 'assets');
+  input.generation.navigation[0].children.push({ pageId: 'assets' });
+  assert.throws(() => generation.compile(snapshot, input), /Duplicate|navigation/i);
+});
+test('every referenced functional node requires an explicit mapped or excluded disposition',()=>{
+ const templates=require(path.join(root,'scripts/template-contract.cjs')),lib=require(path.join(root,'scripts/generation-contract.cjs')),snapshot=templates.loadBundledTemplate();
+ const scope={schemaVersion:3,pages:[{id:'assets',title:'资产',referencePage:'models-page',regions:[{id:'list',pattern:'management-list'}]}],requirements:[{id:'A-01',pages:['assets'],source:{type:'prd',reference:'fixture',statement:'Fixture only.'}}],generation:{}};
+ const fixed=lib.compile(snapshot,scope);assert.ok(fixed.pendingReferenceElements.length);const first=fixed.pendingReferenceElements[0];
+ scope.generation.referenceDecisions=[{pageId:first.pageId,nodeIds:[first.nodeId],decision:'not-applicable',requirementId:'A-01',reason:'Synthetic fixture excludes this example node.'}];
+ assert.equal(lib.compile(snapshot,scope).pendingReferenceElements.length,fixed.pendingReferenceElements.length-1);
+ scope.generation.referenceDecisions.push(scope.generation.referenceDecisions[0]);assert.throws(()=>lib.compile(snapshot,scope),/duplicate reference element/);
+});
+test('fixed pagination and modal form scenarios match their actual parameters',()=>{
+ const templates=require(path.join(root,'scripts/template-contract.cjs')),lib=require(path.join(root,'scripts/generation-contract.cjs')),snapshot=templates.loadBundledTemplate();
+ const scope={schemaVersion:3,pages:[{id:'assets',title:'资产',referencePage:'models-page',regions:[{id:'list',pattern:'management-list',parameters:{pagination:{mode:'fixed',fixedPageSize:15,minimumTestPages:3}}},{id:'edit',pattern:'edit-form',parameters:{edit:{presentation:'modal'}}}]}],requirements:[{id:'A-01',pages:['assets'],source:{type:'prd',reference:'fixture',statement:'Fixture only.'}}]};
+ const fixed=lib.compile(snapshot,scope);assert.match(fixed.scenarios.find(s=>s.capabilityId==='pagination'&&s.id.endsWith('page-size')).expected,/固定容量/);assert.equal(fixed.bindings.find(s=>s.capabilityId==='dialog').parameters.presentation,'modal');
+ scope.pages[0].regions[1].parameters.dialog={presentation:'drawer'};assert.throws(()=>lib.compile(snapshot,scope),/presentation|呈现/);
+});
+test('optional shell and second-region capabilities can be adopted without borrowing another region binding',()=>{
+ const snapshot=templates.loadBundledTemplate(),input=scope();input.pages[0].regions.push({id:'second',pattern:'content'});
+ input.generation.decisions=[{pageId:'app-shell',regionId:'shell',capabilityId:'menu',decision:'adopted',requirementId:'A-01',reason:'Fixture shell menu.'},{pageId:'assets',regionId:'second',capabilityId:'columns',decision:'adopted',requirementId:'A-01',reason:'Fixture second table.'}];
+ const fixed=generation.compile(snapshot,input);assert.ok(fixed.bindings.some(b=>b.id==='app-shell/shell/menu'));assert.ok(fixed.bindings.some(b=>b.id==='assets/second/columns'));
+});
+test('adopted reference controls get individual scenarios even when they share a core capability',()=>{
+ const snapshot=templates.loadBundledTemplate(),input=scope(),draft=generation.compile(snapshot,input),node=draft.pendingReferenceElements.find(item=>item.events.length&&(!item.capabilities.length||item.capabilities.includes('interaction')));
+ input.generation.referenceDecisions=[{pageId:node.pageId,nodeIds:[node.nodeId],decision:'mapped',bindingIds:['app-shell/shell/interaction'],requirementId:'A-01',reason:'Fixture adapts this control to its sourced outcome.'}];
+ const fixed=generation.compile(snapshot,input);assert.ok(fixed.scenarios.some(item=>item.referenceNodeId===node.nodeId&&item.bindingId==='app-shell/shell/interaction'));
+});
+test('read-only planning exposes compact summaries and individual reference fragments',()=>{
+ const fixed=generation.compile(templates.loadBundledTemplate(),scope()),summary=generation.view(fixed);assert.equal(summary.readOnly,true);assert.ok(summary.referenceReview.pendingCount>0);assert.ok(!summary.definition);assert.ok(Buffer.byteLength(JSON.stringify(summary))<25000);
+ const group=summary.referenceReview.fragments[0],detail=generation.view(fixed,{page:group.pageId,fragment:group.fragment});assert.ok(detail.referenceReview.elements.length);assert.ok(detail.referenceReview.elements.every(item=>item.fragment===group.fragment));assert.throws(()=>generation.view(fixed,{page:'missing'}),/page/);
+});

package/scripts/prototype-inventory-test.js

@@ -0,0 +1,43 @@
+'use strict';
+const test = require('node:test'), assert = require('node:assert/strict'), fs = require('node:fs'), path = require('node:path'), os = require('node:os');
+const install = path.join(__dirname, 'lib/installation.js');
+const skills = fs.existsSync(install) ? require(install).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
+const root = path.join(skills, 'i3-ui-prototype'), inventory = require(path.join(root, 'scripts/template-inventory.cjs'));
+const builtin = path.join(root, 'assets/templates/enterprise-admin');
+test('the complete reference inventory accounts for every route, fragment, component and event', () => {
+  const value = inventory.scan(builtin);
+  assert.equal(value.routes.length, 44); assert.equal(value.pages.length, 35); assert.equal(value.fragments.length, 93);
+  assert.equal(Object.keys(value.components).length, 116); assert.equal(value.eventCount, 595);
+  assert.equal(value.unknownComponents.length, 0);
+  assert.ok(value.fragments.every(fragment => fragment.nodes.length && fragment.digest));
+  assert.ok(value.fragments.every(fragment => fragment.nodes.every(node => node.id && node.tag && node.attributes)));
+  assert.equal(value.components.Tree.classification.capabilities.includes('hierarchy'), true);
+  assert.ok(value.files['reference/src/shared/columns.js']);
+  assert.ok(value.components.ColumnSettings.classification.source.endsWith('ColumnSettings.html'));
+});
+function fixture(t) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'i3-inventory-'));
+  t.after(() => fs.rmSync(directory, { recursive: true, force: true }));
+  fs.writeFileSync(path.join(directory, 'index.html'), '<script type="application/json" id="prototype-offline-routes">[{"path":"/items","component":"./Items.js"}]</script>\n<template data-source="reference/Items.html">\n<main><template data-component="Button" data-on-click="save">保存</template></main>\n</template>\n');
+  fs.writeFileSync(path.join(directory, 'component-inventory.json'), JSON.stringify({ schemaVersion: 1, components: { Button: { kind: 'framework', capabilities: ['interaction'] } } }));
+  return directory;
+}
+test('a removed event, route or non-HTML source file cannot keep the old complete inventory', t => {
+  const directory = fixture(t), file = path.join(directory, 'index.html'), html = fs.readFileSync(file, 'utf8');
+  fs.writeFileSync(path.join(directory, 'domain.js'), 'original behavior');
+  const baseline = inventory.scan(directory);
+  for (const change of [html.replace(' data-on-click="save"', ''), html.replace('/items', '/different')]) {
+    fs.writeFileSync(file, change); assert.throws(() => inventory.verify(directory, baseline), /inventory|changed|清单/i);
+  }
+  fs.writeFileSync(file, html); fs.unlinkSync(path.join(directory, 'domain.js'));
+  assert.throws(() => inventory.verify(directory, baseline), /inventory|changed|清单/i);
+});
+test('unclassified components and unsafe template files fail closed', t => {
+  const directory = fixture(t), file = path.join(directory, 'index.html');
+  fs.appendFileSync(file, '\n<template data-source="reference/Other.html">\n<template data-component="NewWidget"></template>\n</template>\n');
+  assert.throws(() => inventory.scan(directory), /Unclassified.*NewWidget/);
+  fs.unlinkSync(file); fs.writeFileSync(file, '<script id="prototype-offline-routes">[]</script>');
+  fs.symlinkSync(os.tmpdir(), path.join(directory, 'outside'));
+  assert.throws(() => inventory.scan(directory), /symlink/i);
+});
+test('quoted comparison expressions remain complete nodes in replacement templates',t=>{const directory=fixture(t),file=path.join(directory,'index.html');fs.writeFileSync(file,fs.readFileSync(file,'utf8').replace('<main>','<main data-bind-visible="a > b && c < d">'));const fixed=inventory.scan(directory);assert.equal(fixed.fragments[0].nodes[0].attributes['data-bind-visible'],'a > b && c < d');});

package/scripts/prototype-locations-test.js

@@ -0,0 +1,79 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const installation = path.join(__dirname, 'lib/installation.js');
+const skills = fs.existsSync(installation) ? require(installation).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
+const locations = require(path.join(skills, 'i3-ui-prototype/scripts/prototype-locations.cjs'));
+function workspace(t) {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'i3-tool-locations-')));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const project = path.join(root, 'business'), home = path.join(root, 'home');
+  fs.mkdirSync(project); fs.mkdirSync(home);
+  return { project, home, env: {} };
+}
+test('all registered project and global targets keep tools under their host base without writes', t => {
+  const options = workspace(t);
+  for (const agent of locations.registry.agents) {
+    const local = locations.resolveLocations({ ...options, host: agent.id });
+    assert.equal(local.skillsDirectory, path.resolve(options.project, agent.projectSkillsDir));
+    const toolBase = path.dirname(local.skillsDirectory) === options.project ? path.join(options.project, `.${agent.id}`) : path.dirname(local.skillsDirectory);
+    assert.equal(local.toolsDirectory, path.join(toolBase, 'tools/i3-prototype'));
+    assert.notEqual(local.toolsDirectory, path.join(options.project, 'tools/i3-prototype'));
+    assert.equal(local.cacheDirectory, path.join(toolBase, 'cache/i3-prototype'));
+    if (agent.globalSkillsDir) {
+      const global = locations.resolveLocations({ ...options, host: agent.id, scope: 'global' });
+      assert.equal(global.toolsDirectory, path.join(path.dirname(global.skillsDirectory), 'tools/i3-prototype'));
+      assert.ok(global.base.startsWith(options.home + path.sep));
+      assert.equal(global.cacheDirectory, path.join(global.base, 'cache/i3-prototype', global.projectKey));
+    } else assert.throws(() => locations.resolveLocations({ ...options, host: agent.id, scope: 'global' }), /project installation only/);
+  }
+  assert.deepEqual(fs.readdirSync(options.project), []);
+  assert.deepEqual(fs.readdirSync(options.home), []);
+});
+test('global caches distinguish same-name projects while path resolution remains read-only', t => {
+  const options = workspace(t), other = path.join(options.home, 'business'); fs.mkdirSync(other);
+  const first = locations.resolveLocations({ ...options, host: 'codebuddy', scope: 'global' });
+  const second = locations.resolveLocations({ ...options, project: other, host: 'codebuddy', scope: 'global' });
+  assert.notEqual(first.projectKey, second.projectKey);
+  assert.notEqual(first.cacheDirectory, second.cacheDirectory);
+  assert.deepEqual(fs.readdirSync(options.project), []);
+  assert.equal(fs.existsSync(path.join(options.home, '.codebuddy')), false);
+});
+test('CLI path output distinguishes installation scope from the preparation scope file without writes', async t => {
+  const options = workspace(t), cli = require(path.join(skills, 'i3-ui-prototype/scripts/native-pilot.cjs'));
+  for (const scope of ['project', 'global']) {
+    const result = await cli.main(['paths', '--project', options.project, '--home', options.home, '--host', 'codebuddy', '--scope', scope, '--id', 'assets']);
+    assert.equal(result.scope, scope);
+    assert.equal(result.scopeFile, path.join(options.project, 'prototypes/.preparation/assets/scope.json'));
+  }
+  assert.deepEqual(fs.readdirSync(options.project), []);
+  assert.deepEqual(fs.readdirSync(options.home), []);
+});
+test('CodeBuddy and WorkBuddy share project tools but use separate global roots; Codex follows agents', t => {
+  const options = workspace(t), get = (host, scope = 'project') => locations.resolveLocations({ ...options, host, scope });
+  assert.equal(get('codebuddy').toolsDirectory, get('workbuddy').toolsDirectory);
+  assert.notEqual(get('codebuddy', 'global').toolsDirectory, get('workbuddy', 'global').toolsDirectory);
+  assert.equal(get('codex').base, path.join(options.project, '.agents'));
+  assert.equal(get('codex', 'global').base, path.join(options.home, '.agents'));
+});
+test('configuration roots and aliases follow installer mapping and explicit global checks exclude business paths', t => {
+  const options = workspace(t);
+  const context = locations.resolveLocations({ ...options, host: 'claude', scope: 'global', env: { CLAUDE_CONFIG_DIR: path.join(options.home, 'custom claude') } });
+  assert.equal(context.base, path.join(options.home, 'custom claude'));
+  assert.equal(context.host, 'claude-code');
+  const opencode = locations.resolveLocations({ ...options, host: 'opencode', env: { XDG_CONFIG_HOME: path.join(options.home, 'config') }, scope: 'global' });
+  assert.equal(opencode.base, path.join(options.home, 'config/opencode'));
+  assert.ok(locations.toolCandidates(context).every(item => !item.root.startsWith(options.project + path.sep)));
+  assert.throws(() => locations.resolveLocations({ ...options, host: 'unknown' }), /Unknown host/);
+  assert.throws(() => locations.resolveLocations({ ...options, scope: 'all' }), /scope/);
+});
+test('new project and global tools precede both legacy layouts', t => {
+  const options = workspace(t), context = locations.resolveLocations({ ...options, host: 'codex' });
+  const paths = locations.toolCandidates(context);
+  assert.deepEqual(paths.map(item => item.source), ['project-tool', 'global-tool', 'legacy-project-tool', 'legacy-project-tool']);
+  assert.ok(paths[0].root.includes('/.agents/tools/i3-prototype/antdv-cli/'));
+  assert.ok(paths.at(-1).root.includes('/.prototype-tools/node_modules/'));
+});

package/scripts/prototype-project-test.js

@@ -0,0 +1,183 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const installation = path.join(__dirname, 'lib/installation.js');
+const skills = fs.existsSync(installation) ? require(installation).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
+const scripts = path.join(skills, 'i3-ui-prototype/scripts');
+const native = require(path.join(scripts, 'native-pilot-lib.cjs'));
+const registry = require(path.join(scripts, 'project-registry.cjs'));
+const read = file => JSON.parse(fs.readFileSync(file, 'utf8'));
+function fixture(t) {
+  const project = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'i3-project-')));
+  t.after(() => fs.rmSync(project, { recursive: true, force: true }));
+  const scope = { schemaVersion: 2, moduleIds: ['asset-management', 'work-orders', 'asset-management'], title: '资产原型',
+    pages: [{ id: 'assets', title: '资产台账', referencePage: 'models-page', regions: [{ id: 'list', mode: 'management-list' }] }],
+    requirements: [{ id: 'ASSET-01', text: '查询、多选、分页和批量状态变更', pages: ['assets'], source: { type: 'prd', reference: 'PRD-assets-v1.2#ASSET-01', statement: 'Isolated fixture with explicitly named project modules.' } }], exemptions: [] };
+  const file = path.join(project, 'scope.json');
+  const create = (id = 'assets') => { fs.writeFileSync(file, JSON.stringify(scope)); return native.createPrototype({ project, id, scope: file, expertMode: 'template' }); };
+  return { project, scope, create };
+}
+test('new prototypes use one shared nested index and derive module associations from fixed scope', t => {
+  const { project, scope, create } = fixture(t), created = create();
+  const index = read(path.join(project, 'prototypes/index.json'));
+  assert.deepEqual(index.prototypes[0].appliesTo, ['asset-management', 'work-orders']);
+  assert.equal(index.prototypes[0].directory, 'prototypes/assets');
+  assert.deepEqual(read(path.join(created.directory, 'inputs/scope.json')), scope);
+  for (const name of ['.i3-ui-prototypes.json', '.i3-ui-prototypes.lock', '.prototype-preparation', '.playwright-cli', 'ui-templates']) assert.equal(fs.existsSync(path.join(project, name)), false, name);
+  assert.equal(fs.existsSync(path.join(project, 'prototypes/.index.lock')), false);
+});
+test('scope module validation rejects invented paths and malformed declarations before any output', t => {
+  const { project, scope, create } = fixture(t);
+  for (const value of [undefined, null, 'assets', [null], ['../assets'], ['src/assets'], ['*'], [''], ['asset management']]) {
+    scope.moduleIds = value;
+    assert.throws(() => create(), /moduleIds|module identifier/i);
+    assert.equal(fs.existsSync(path.join(project, 'prototypes')), false);
+  }
+  scope.moduleIds = [];
+  create();
+  assert.deepEqual(registry.query({ project, module: 'asset-management' }).matches, []);
+  assert.deepEqual(registry.query({ project }).unbound.map(entry => entry.id), ['assets']);
+});
+test('index lookup is read-only, detects overlapping prototypes and never treats unbound as global', t => {
+  const { project, scope, create } = fixture(t);
+  assert.equal(registry.query({ project }).prototypes.length, 0);
+  assert.deepEqual(fs.readdirSync(project), []);
+  create('first'); create('second');
+  const result = registry.query({ project, module: 'asset-management' });
+  assert.equal(result.selection, 'ambiguous');
+  assert.deepEqual(result.matches.map(entry => entry.id), ['first', 'second']);
+  scope.moduleIds = []; create('exploration');
+  assert.equal(registry.query({ project, module: 'work-orders' }).matches.length, 2);
+  assert.equal(registry.query({ project, module: 'other' }).matches.length, 0);
+});
+test('a legacy-only project keeps one active index until explicitly migrated and preserves its instances', t => {
+  const { project, create } = fixture(t), first = create('old');
+  const before = native.manifest(first.directory);
+  fs.renameSync(path.join(project, 'prototypes/index.json'), path.join(project, '.i3-ui-prototypes.json'));
+  create('new');
+  assert.equal(fs.existsSync(path.join(project, 'prototypes/index.json')), false);
+  assert.equal(registry.query({ project }).legacy, true);
+  assert.equal(read(path.join(project, '.i3-ui-prototypes.json')).prototypes.length, 2);
+  assert.deepEqual(native.manifest(first.directory), before);
+});
+test('conflicting indices and an old active writer block creation without overwriting user content', t => {
+  const { project, create } = fixture(t); create('first');
+  const before = fs.readFileSync(path.join(project, 'prototypes/index.json'));
+  fs.writeFileSync(path.join(project, '.i3-ui-prototypes.json'), JSON.stringify({ schemaVersion: 1, prototypes: [] }));
+  assert.throws(() => create('second'), /conflict|indices/i);
+  assert.equal(fs.existsSync(path.join(project, 'prototypes/second')), false);
+  assert.deepEqual(fs.readFileSync(path.join(project, 'prototypes/index.json')), before);
+  fs.unlinkSync(path.join(project, '.i3-ui-prototypes.json'));
+  fs.writeFileSync(path.join(project, '.i3-ui-prototypes.lock'), 'existing writer');
+  assert.throws(() => create('second'), /lock|writer/i);
+  assert.equal(fs.readFileSync(path.join(project, '.i3-ui-prototypes.lock'), 'utf8'), 'existing writer');
+});
+test('failed atomic index publication removes only the newly created prototype', t => {
+  const { project, create } = fixture(t); create('first');
+  const original = fs.readFileSync(path.join(project, 'prototypes/index.json'));
+  const rename = fs.renameSync;
+  fs.renameSync = (from, to) => { if (to === path.join(project, 'prototypes/index.json')) throw new Error('fixture index write failed'); return rename(from, to); };
+  try { assert.throws(() => create('second'), /fixture index write failed/); } finally { fs.renameSync = rename; }
+  assert.deepEqual(fs.readFileSync(path.join(project, 'prototypes/index.json')), original);
+  assert.equal(fs.existsSync(path.join(project, 'prototypes/second')), false);
+  assert.deepEqual(fs.readdirSync(path.join(project, 'prototypes')).sort(), ['first', 'index.json']);
+});
+test('old scope contracts remain valid and legacy HTML creation also uses the shared index', t => {
+  const { project, scope, create } = fixture(t);
+  scope.schemaVersion = 1; delete scope.moduleIds;
+  const first = create();
+  assert.equal(native.inspect(first.directory).status, 'passed');
+  assert.deepEqual(registry.query({ project }).unbound.map(entry => entry.id), ['assets']);
+  const legacy = require(path.join(scripts, 'prototype-lib.cjs'));
+  const html = legacy.initPrototype({ project, id: 'html', template: 'classic-admin', expertMode: 'template' });
+  assert.equal(legacy.checkPrototype(html.directory).status, 'passed');
+  assert.equal(registry.query({ project }).prototypes.length, 2);
+  assert.equal(fs.existsSync(path.join(project, '.i3-ui-prototypes.json')), false);
+});
+test('legacy human module labels remain searchable without rewriting their old scope', t => {
+  const { project, scope, create } = fixture(t); scope.schemaVersion = 1; delete scope.moduleIds;
+  const directory = create().directory, before = native.manifest(directory), file = path.join(project, 'prototypes/index.json'), index = read(file);
+  index.prototypes[0].appliesTo = ['资产管理']; fs.writeFileSync(file, JSON.stringify(index));
+  assert.equal(registry.query({ project, module: '资产管理' }).matches[0].id, 'assets');
+  assert.deepEqual(native.manifest(directory), before);
+});
+test('explicitly accepting a revised scope updates the index and invalid associations cannot be selected', t => {
+  const { project, create } = fixture(t), directory = create().directory;
+  const scopeFile = path.join(directory, 'inputs/scope.json'), scope = read(scopeFile);
+  scope.moduleIds = ['maintenance']; fs.writeFileSync(scopeFile, JSON.stringify(scope));
+  assert.equal(registry.query({ project, module: 'asset-management' }).status, 'failed');
+  assert.deepEqual(registry.query({ project, module: 'asset-management' }).matches, []);
+  const candidate = native.manifest(directory);
+  native.revise(directory, { revision: 'r002', expectedRevision: candidate.revision, expectedDigest: candidate.digest, acceptInputs: true });
+  assert.deepEqual(read(path.join(project, 'prototypes/index.json')).prototypes[0].appliesTo, ['maintenance']);
+  assert.equal(registry.query({ project, module: 'maintenance' }).selection, 'matched');
+  assert.equal(native.inspect(directory).status, 'passed');
+});
+test('synchronizing the index uses fixed accepted inputs and leaves the candidate unchanged', t => {
+  const { project, create } = fixture(t), directory = create().directory, before = native.manifest(directory);
+  const indexFile = path.join(project, 'prototypes/index.json'), index = read(indexFile);
+  index.prototypes[0].appliesTo = ['invented']; fs.writeFileSync(indexFile, JSON.stringify(index));
+  assert.equal(registry.query({ project, module: 'invented' }).status, 'failed');
+  const rename = fs.renameSync; let instanceLocked = false;
+  fs.renameSync = (from, to) => { if (to === indexFile) instanceLocked = fs.existsSync(path.join(directory, '.prototype-write.lock')); return rename(from, to); };
+  try { assert.equal(native.synchronizeIndex({ project, id: 'assets' }).status, 'synchronized'); } finally { fs.renameSync = rename; }
+  assert.equal(instanceLocked, true, 'Synchronization must lock the candidate while reading its fixed inputs');
+  assert.deepEqual(native.manifest(directory), before);
+  assert.equal(registry.query({ project, module: 'invented' }).matches.length, 0);
+  assert.equal(registry.query({ project, module: 'asset-management' }).matches.length, 1);
+  const scope = read(path.join(directory, 'inputs/scope.json')); scope.moduleIds = ['pending'];
+  fs.writeFileSync(path.join(directory, 'inputs/scope.json'), JSON.stringify(scope));
+  assert.throws(() => native.synchronizeIndex({ project, id: 'assets' }), /input|contract|合同/i);
+});
+test('an index failure while revising restores prototype metadata and preserves the previous registry', t => {
+  const { project, create } = fixture(t), directory = create().directory;
+  const metadataFile = path.join(directory, 'prototype.json'), before = fs.readFileSync(metadataFile);
+  const indexFile = path.join(project, 'prototypes/index.json'), indexBefore = fs.readFileSync(indexFile);
+  const scopeFile = path.join(directory, 'inputs/scope.json'), scope = read(scopeFile); scope.moduleIds = ['maintenance']; fs.writeFileSync(scopeFile, JSON.stringify(scope));
+  const candidate = native.manifest(directory), rename = fs.renameSync;
+  fs.renameSync = (from, to) => { if (to === indexFile) throw new Error('fixture revise index failure'); return rename(from, to); };
+  try { assert.throws(() => native.revise(directory, { revision: 'r002', expectedRevision: candidate.revision, expectedDigest: candidate.digest, acceptInputs: true }), /fixture revise index failure/); }
+  finally { fs.renameSync = rename; }
+  assert.deepEqual(fs.readFileSync(metadataFile), before);
+  assert.deepEqual(fs.readFileSync(indexFile), indexBefore);
+});
+test('legacy index migration previews without writes, archives source bytes and preserves prototype identity', t => {
+  const { project, create } = fixture(t), directory = create().directory, candidate = native.manifest(directory);
+  const current = path.join(project, 'prototypes/index.json'), old = path.join(project, '.i3-ui-prototypes.json');
+  fs.renameSync(current, old); const bytes = fs.readFileSync(old), before = fs.readdirSync(path.join(project, 'prototypes'));
+  const preview = registry.migrate({ project, check: true });
+  assert.equal(preview.status, 'migration-preview');
+  assert.equal(fs.existsSync(current), false);
+  assert.deepEqual(fs.readdirSync(path.join(project, 'prototypes')), before);
+  const result = registry.migrate({ project });
+  assert.equal(result.status, 'migrated');
+  assert.deepEqual(fs.readFileSync(result.backup), bytes);
+  assert.deepEqual(fs.readFileSync(current), bytes);
+  assert.equal(fs.existsSync(old), false);
+  assert.deepEqual(native.manifest(directory), candidate);
+  assert.equal(registry.migrate({ project }).status, 'current');
+});
+test('failed migration rolls back its new index and retains original source and user files', t => {
+  const { project, create } = fixture(t); create();
+  const current = path.join(project, 'prototypes/index.json'), old = path.join(project, '.i3-ui-prototypes.json');
+  fs.renameSync(current, old); const bytes = fs.readFileSync(old);
+  fs.writeFileSync(path.join(project, 'user.md'), 'keep user content');
+  const unlink = fs.unlinkSync;
+  fs.unlinkSync = file => { if (file === old) throw new Error('fixture old source cannot be removed'); return unlink(file); };
+  try { assert.throws(() => registry.migrate({ project }), /fixture old source/); } finally { fs.unlinkSync = unlink; }
+  assert.deepEqual(fs.readFileSync(old), bytes);
+  assert.equal(fs.existsSync(current), false);
+  assert.equal(fs.readFileSync(path.join(project, 'user.md'), 'utf8'), 'keep user content');
+  assert.equal(fs.existsSync(path.join(project, 'prototypes/.index.lock')), false);
+  assert.equal(fs.existsSync(path.join(project, '.i3-ui-prototypes.lock')), false);
+});
+test('migration refuses divergent duplicate indices rather than picking a winner', t => {
+  const { project, create } = fixture(t); create();
+  const current = path.join(project, 'prototypes/index.json'), bytes = fs.readFileSync(current);
+  fs.writeFileSync(path.join(project, '.i3-ui-prototypes.json'), '{"schemaVersion":1,"prototypes":[]}');
+  assert.throws(() => registry.migrate({ project }), /conflict|indices/i);
+  assert.deepEqual(fs.readFileSync(current), bytes);
+});