@givolt/i3-composer-agent 3.2.1 → 4.0.1

package/scripts/ui-prototype-recovery-test.js

@@ -1,81 +0,0 @@
-'use strict';
-const test=require('node:test'),assert=require('node:assert/strict'),path=require('node:path'),fs=require('node:fs');
-const installation=path.join(__dirname,'lib/installation.js');
-const scripts=path.join(fs.existsSync(installation)?require(installation).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');
-const E=require(path.join(scripts,'execution-evidence.cjs')),P=require(path.join(scripts,'execution-policy.cjs'));
-const R=()=>require(path.join(scripts,'execution-recovery.cjs'));
-const source=()=>({prompts:[{line:1,digest:'actual-user-task',text:'实现原型'}],calls:[],contextLine:0});
-test('missing frontend returns the actual Skill and concrete retry instruction',()=>{
- const missing=R().missing({source:source(),binding:{sessionId:'s1',entryLine:1,contextLine:0},policy:P.create({id:P.AUTO_ID,mode:'template'})});
- assert.ok(missing.includes('frontend'));assert.ok(missing.includes('antdv'));
- const message=R().instruction(missing);assert.match(message,/i3-frontend-ui-engineering/);assert.match(message,/成功|success/);assert.match(message,/重试|retry/);
-});
-test('recovery correlates a later successful native Skill and a successful retry',()=>{
- const index={bindings:{}},s=source(),context={source:s,sessionId:'s1',directory:'/p/prototypes/a',event:'PreToolUse',eventKey:'denied-write-1'};
- const denied={deny:true,missing:['frontend'],reason:'missing frontend'};
- const first=R().record(index,context,denied);assert.equal(first.recovery.status,'required');
- R().record(index,context,denied);assert.equal(Object.values(index.recoveries)[0].total,1,'Duplicate callbacks do not spend another attempt');
- const rows=[{type:'user',sessionId:'s1',message:{content:'实现原型'}},{type:'assistant',sessionId:'s1',message:{content:[{type:'tool_use',id:'real-front',name:'Skill',input:{skill:'i3-frontend-ui-engineering'}}]}},{type:'user',sessionId:'s1',message:{content:[{type:'tool_result',tool_use_id:'real-front',content:'Skill loaded successfully'}]}}];
- s.calls=E.parse(rows.map(row=>JSON.stringify(row)).join('\n'));
- const ready=R().record(index,{...context,eventKey:'retry-2'},{continue:true});assert.equal(ready.recovery.status,'ready-to-retry');
- const recovered=R().record(index,{...context,event:'PostToolUse',eventKey:'retry-2-result',retrySucceeded:true,retry:{toolCallId:'retry-write',requestLine:4,resultLine:5}},{continue:true});
- assert.equal(recovered.recovery.status,'recovered');assert.equal(recovered.recovery.invocations[0].toolCallId,'real-front');
-});
-test('duplicate callback counts stay idempotent without replaying a stale denial after a successful Skill',()=>{
- const index={bindings:{}},s=source(),context={source:s,sessionId:'s1',directory:'/p/prototypes/a',event:'PreToolUse',eventKey:'same-callback'};
- R().record(index,context,{deny:true,missing:['frontend'],reason:'missing frontend'});
- s.calls=[{skill:'frontend',sessionId:'s1',toolCallId:'front',requestLine:2,resultLine:3,success:true}];
- const current=R().record(index,context,{continue:true});
- assert.notEqual(current.deny,true,'Return the current gate decision, not its cached historical denial');
- assert.equal(current.recovery.total,1);assert.equal(current.recovery.status,'ready-to-retry');
-});
-test('failed and stale Skill results do not recover and Stop correction is bounded across begin calls',()=>{
- const index={bindings:{}},s=source(),context={source:s,sessionId:'s1',directory:'/p/prototypes/a',event:'Stop'};
- s.calls=[{skill:'frontend',sessionId:'s1',requestLine:2,resultLine:3,success:false}];
- const feedback={feedback:true,missing:['frontend'],reason:'load frontend'};
- for(let n=1;n<=2;n++)assert.equal(R().record(index,{...context,eventKey:'stop-'+n},feedback).feedback,true);
- index.bindings={};
- const exhausted=R().record(index,{...context,eventKey:'stop-3'},feedback);assert.equal(exhausted.feedback,undefined);assert.equal(exhausted.recovery.status,'blocked');assert.match(exhausted.context,/停止重复催调/);
- const denied=R().record(index,{...context,event:'PreToolUse',eventKey:'write-3'},{deny:true,missing:['frontend'],reason:'load frontend'});assert.equal(denied.deny,true);
- s.contextLine=10;s.calls=[{skill:'frontend',sessionId:'s1',requestLine:2,resultLine:3,success:true}];
- assert.notEqual(R().record(index,{...context,eventKey:'old-load'},{continue:true}).recovery?.status,'recovered');
- assert.ok(R().missing({source:s,binding:{sessionId:'s1',association:'automatic'},policy:P.create({id:P.AUTO_ID,mode:'template'})}).includes('frontend'),'Pre-compaction Skill success remains invalid in the new context');
-});
-test('flat native Hook feedback remains metadata and cannot reset the human task or recovery budget',()=>{
- const rows=[{type:'message',role:'user',sessionId:'s1',content:[{type:'input_text',text:'实现原型'}]},{type:'message',role:'user',sessionId:'s1',providerData:{isMeta:true},content:[{type:'input_text',text:'补调 frontend 后继续'}]}];
- const text=rows.map(row=>JSON.stringify(row)).join('\n');
- assert.equal(E.describe(text).prompts.length,1);assert.equal(E.describe(text).prompts[0].text,'实现原型');
-});
-test('a missing Skill has one budget even when the set of other missing Skills changes',()=>{
- const index={},context={source:source(),sessionId:'s1',directory:'/p/prototypes/a',event:'Stop'};
- for(const [n,missing] of [['1',['frontend','antdv']],['2',['frontend']]])assert.equal(R().record(index,{...context,eventKey:n},{feedback:true,missing}).feedback,true);
- const third=R().record(index,{...context,eventKey:'3'},{feedback:true,missing:['frontend','uiux']});
- assert.equal(third.recovery.status,'blocked');assert.equal(third.feedback,undefined);assert.equal(third.recovery.counts.frontend,2);
-});
-test('native output resumes Stop for recovery and shows the user an exhausted-budget warning',()=>{
- const format=require(path.join(scripts,'hosts/codebuddy.cjs')).format;
- assert.deepEqual(format({feedback:true,reason:'补调'},'Stop').output,{continue:false,reason:'补调'});
- const blocked=format({context:'当前仍被阻塞',recovery:{status:'blocked'}},'Stop').output;
- assert.equal(blocked.continue,true);assert.equal(blocked.systemMessage,'当前仍被阻塞');
- assert.equal(format({deny:true,reason:'缺 Skill'},'PreToolUse').output.hookSpecificOutput.permissionDecision,'deny');
- assert.equal(format({continue:true,context:'实施前加载'},'UserPromptSubmit').output.hookSpecificOutput.additionalContext,'实施前加载');
-});
-test('a stage evidence recovery requires the same verified stage and its successful native retry',()=>{
- const index={},context={source:source(),sessionId:'s1',directory:'/p/prototypes/a',event:'PreToolUse',eventKey:'denied-build',stage:'implementation'};
- R().record(index,context,{deny:true,missing:['execution-evidence']});
- const other=R().record(index,{...context,eventKey:'another-stage',stage:'browser-entry',resolved:['execution-evidence'],retrySucceeded:true,event:'PostToolUse'},{continue:true});
- assert.equal(other.recovery.status,'required');
- const ready=R().record(index,{...context,eventKey:'verified-build',resolved:['execution-evidence']},{continue:true});
- assert.equal(ready.recovery.status,'ready-to-retry');
- const retry=R().record(index,{...context,eventKey:'successful-build',resolved:['execution-evidence'],retrySucceeded:true,event:'PostToolUse',retry:{toolCallId:'actual-build-result',requestLine:4,resultLine:5}},{continue:true});
- assert.equal(retry.recovery.status,'recovered');assert.equal(retry.recovery.retry.toolCallId,'actual-build-result');
-});
-test('an old successful callback cannot recover a later stage denial',()=>{
- const s=source();s.calls=[{toolCallId:'old',requestLine:2,resultLine:3,success:true}];
- const index={},context={source:s,sessionId:'s1',directory:'/p/prototypes/a',stage:'implementation'};
- R().record(index,{...context,event:'PreToolUse',eventKey:'deny'},{deny:true,missing:['execution-evidence']});
- const stale=R().record(index,{...context,event:'PostToolUse',eventKey:'old-result',resolved:['execution-evidence'],retrySucceeded:true,retry:s.calls[0]},{continue:true});
- assert.equal(stale.recovery.status,'ready-to-retry');
- const current=R().record(index,{...context,event:'PostToolUse',eventKey:'new-result',resolved:['execution-evidence'],retrySucceeded:true,retry:{toolCallId:'new',requestLine:4,resultLine:5}},{continue:true});
- assert.equal(current.recovery.status,'recovered');assert.equal(current.recovery.retry.feedbackLine,3);
-});

package/scripts/ui-prototype-registration-test.js

@@ -1,53 +0,0 @@
-'use strict';
-const prototypeScripts=(()=>{const fs=require('node:fs'),path=require('node:path'),file=path.join(__dirname,'lib/installation.js');return path.join(fs.existsSync(file)?require(file).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');})();
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const R = require(prototypeScripts+'/codebuddy-registration.cjs');
-const options = { action: 'enable', scope: 'project', product: 'ide', base: '/work/project/.codebuddy',
-  project: '/work/project', nodePath: '/runtime with spaces/node', scriptPath: '/work/project/.codebuddy/skills/i3-ui-prototype/scripts/hosts/codebuddy.cjs', scriptDigest: 'a'.repeat(64) };
-test('registration planning preserves unrelated hooks and never grants permissions', () => {
-  const before = { theme: 'dark', hooks: { PreToolUse: [{ matcher: 'Write', hooks: [{ type: 'command', command: 'original-check' }] }] } };
-  const result = R.plan({ ...options, currentText: JSON.stringify(before) });
-  const after = JSON.parse(result.afterText);
-  assert.equal(after.theme, 'dark'); assert.deepEqual(after.hooks.PreToolUse[0], before.hooks.PreToolUse[0]);
-  assert.ok(result.summary.events.includes('PostToolUse'));
-  assert.match(after.hooks.PreToolUse[1].hooks[0].command, /'\/runtime with spaces\/node'/);
-  assert.equal(result.recordAfter.active, undefined);
-  assert.equal(result.summary.status, 'registered');
-});
-test('repeated enable is idempotent, disable removes only owned groups', () => {
-  const first = R.plan({ ...options, currentText: '{"userOption":42}' });
-  const again = R.plan({ ...options, currentText: first.afterText, record: first.recordAfter });
-  assert.equal(again.afterText, first.afterText);
-  const removed = R.plan({ ...options, action: 'disable', currentText: again.afterText, record: again.recordAfter });
-  assert.equal(JSON.parse(removed.afterText).userOption, 42);
-  assert.equal(Object.values(JSON.parse(removed.afterText).hooks).flat().length, 0);
-});
-test('missing ownership and modified owned hooks cannot be force adopted', () => {
-  const first = R.plan({ ...options, currentText: '{}' });
-  assert.throws(() => R.plan({ ...options, currentText: first.afterText }), /ownership|Ownership/);
-  const edited = JSON.parse(first.afterText); edited.hooks.Stop[0].hooks[0].timeout = 9;
-  assert.throws(() => R.plan({ ...options, currentText: JSON.stringify(edited), record: first.recordAfter }), /modified|changed/);
-  assert.throws(() => R.plan({ ...options, currentText: '{broken' }), /JSON/);
-});
-test('global CLI registration and defaults remain separate from actual activation', () => {
-  const keep = R.plan({ ...options, action: 'keep', currentText: null });
-  assert.equal(keep.afterText, null); assert.equal(keep.summary.status, 'not-enabled');
-  const global = R.plan({ ...options, scope: 'global', base: '/user/.codebuddy', product: 'cli', currentText: '{}' });
-  assert.equal(global.summary.status, 'pending-host-review');
-  assert.match(global.recordAfter.groups.Stop.hooks[0].command, /--scope' 'global/);
-  assert.throws(() => R.plan({ ...options, product: 'workbuddy' }), /product/);
-});
-test('configuration transaction refuses stale previews and restores only its own failed write in memory', () => {
-  const change = R.plan({ ...options, currentText: '{}' });
-  const files = new Map([[change.settingsPath, '{}']]); let fail = true;
-  const io = { read: file => files.get(file) ?? null, write(file, text) {
-    if (file === change.recordPath && fail) { fail = false; throw new Error('record write failed'); }
-    if (text === null) files.delete(file); else files.set(file, text);
-  } };
-  assert.throws(() => R.apply(change, io), /record write failed/);
-  assert.equal(files.get(change.settingsPath), '{}');
-  files.set(change.settingsPath, '{"userEdit":true}');
-  assert.throws(() => R.apply(change, io), /changed after preview/);
-  assert.equal(files.get(change.settingsPath), '{"userEdit":true}');
-});

package/scripts/ui-prototype-template-test.js

@@ -1,261 +0,0 @@
-'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 legacyFixture = require('./lib/prototype-fixture.cjs');
-const installationFile = path.join(__dirname, 'lib/installation.js');
-const skillsDirectory = fs.existsSync(installationFile) ? require(installationFile).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
-const contract = require(path.join(skillsDirectory, 'i3-ui-prototype/scripts/template-contract.cjs'));
-
-function fixture(t) {
-  const project = fs.mkdtempSync(path.join(os.tmpdir(), 'i3-ui-template-'));
-  t.after(() => fs.rmSync(project, { recursive: true, force: true }));
-  return legacyFixture.prepareTemplate(contract, { project });
-}
-function edit(directory, change) {
-  const file = path.join(directory, 'index.html');
-  fs.writeFileSync(file, change(fs.readFileSync(file, 'utf8')));
-}
-function parameters(index) {
-  return { definition: index.definition, bindings: index.bindings, regions: index.regions, scope: { requirements: [], exemptions: [] }, decisions: [] };
-}
-test('theme remains optional and its explicit preset binding rejects invalid defaults and identifiers', t => {
-  const { directory, index }=fixture(t);
-  assert.equal(index.bindings.some(binding=>binding.capabilityId==='theme'),false);
-  edit(directory,html=>html.replace(/<!-- OPTIONAL_FOUR_THEMES:[\s\S]*?(<aside[\s\S]*?<\/aside>)\s*-->/,'$1'));
-  const themed=contract.syncTemplate(directory);
-  assert.equal(themed.bindings.filter(binding=>binding.capabilityId==='theme').length,1,'Uncommenting the shipped opt-in snippet must create exactly one binding');
-  assert.equal(contract.projectAdminListContent(contract.loadTemplate(directory)).pageTitle,'设备管理','The opt-in preserves normal HTML content projection');
-  const source={type:'user',reference:'theme-request',statement:'明亮、暗黑、清新、科技，默认明亮'};
-  const inputs=parameters(themed);inputs.scope.requirements=[{id:'THEME-1',text:source.statement,source,capabilities:[{pageId:'devices',regionId:'device-list',capabilityId:'theme'}]}];
-  assert.equal(contract.checkCapabilities(inputs).status,'passed');
-  assert.equal(contract.checkCapabilities(inputs).requiredScenarios.filter(s=>s.id.includes('/theme/')).length,3);
-  for(const values of [{},{defaultTheme:'dark',presets:['light','dark','fresh','tech']},{defaultTheme:'light',presets:['light','dark','fresh',4]},{defaultTheme:'light',presets:['light','dark','fresh','fresh']}]){
-    const broken=structuredClone(inputs);broken.bindings.find(binding=>binding.capabilityId==='theme').parameters=values;
-    assert.equal(contract.checkCapabilities(broken).status,'failed',JSON.stringify(values));
-  }
-});
-test('an enabled theme cannot exempt its required acceptance while retaining the binding', t => {
-  const {directory}=fixture(t);
-  edit(directory,html=>html.replace('<nav class="pagination"',`<aside data-capability-id="theme" data-capability-parameters='{"defaultTheme":"light","presets":["light","dark","fresh","tech"]}'>可选主题</aside><nav class="pagination"`));
-  const index=contract.syncTemplate(directory),fixed=parameters(index),binding=fixed.bindings.find(item=>item.capabilityId==='theme');
-  const scope={requirements:[{id:'THEME-1',text:'四主题',source:{type:'user',reference:'theme-request',statement:'明亮、暗黑、清新、科技'},capabilities:[binding]}],exemptions:[]};
-  const inputRoot=path.join(directory,'fixed-inputs');fs.mkdirSync(inputRoot);
-  const save=()=>{fs.writeFileSync(path.join(inputRoot,'capabilities.json'),JSON.stringify(fixed));fs.writeFileSync(path.join(inputRoot,'scope.json'),JSON.stringify(scope));};
-  save();assert.equal(contract.checkInstanceCapabilities(inputRoot).status,'passed');
-  fixed.decisions=[{bindingId:binding.id,status:'not-applicable',requirementId:'THEME-1'}];
-  scope.exemptions=[{...binding,requirementId:'THEME-1',reason:'Trying to waive acceptance without removing the enabled theme'}];
-  save();const checked=contract.checkInstanceCapabilities(inputRoot);
-  assert.equal(checked.status,'failed');assert.match(checked.errors.join(';'),/enabled theme.*acceptance|主题.*验收/i);
-});
-
-test('pagination supports an explicit adjustable contract without reinterpreting fixedPageSize', t => {
-  const { directory, index } = fixture(t);
-  const legacy = parameters(index);
-  assert.equal(contract.checkCapabilities(legacy).status, 'passed');
-  edit(directory, html => html.replace('"fixedPageSize":10,"minimumTestPages":3', '"mode":"adjustable","defaultPageSize":10,"pageSizeOptions":[10,20,50],"minimumTestPages":3'));
-  const synced = contract.syncTemplate(directory);
-  const binding = synced.bindings.find(entry => entry.capabilityId === 'pagination');
-  assert.deepEqual(binding.parameters, { mode: 'adjustable', defaultPageSize: 10, pageSizeOptions: [10,20,50], minimumTestPages: 3 });
-  assert.equal(contract.checkCapabilities(parameters(synced)).status, 'passed');
-  assert.equal(contract.checkCapabilities(legacy).status, 'passed', 'an existing fixed snapshot remains valid');
-  const oldSnapshot = structuredClone(legacy);
-  const oldPagination = oldSnapshot.definition.capabilities.find(item => item.id === 'pagination');
-  oldSnapshot.definition.version = '1.0.0';
-  oldPagination.parameters = { fixedPageSize: { type: 'integer', required: true, minimum: 1 }, minimumTestPages: { type: 'integer', required: true, minimum: 3 } };
-  assert.equal(contract.checkCapabilities(oldSnapshot).status, 'passed', 'the old fixed-only definition remains independently valid');
-});
-
-test('pagination rejects ambiguous modes and malformed adjustable defaults or options', t => {
-  const { index } = fixture(t);
-  const cases = [
-    { mode: 'automatic', fixedPageSize: 10 },
-    { mode: 10, fixedPageSize: 10 },
-    { mode: 'fixed' },
-    { mode: 'fixed', fixedPageSize: 10, pageSizeOptions: [10,20,50] },
-    { mode: 'fixed', fixedPageSize: 10, defaultPageSize: 10 },
-    { mode: 'adjustable', fixedPageSize: 10, defaultPageSize: 10, pageSizeOptions: [10,20,50] },
-    { mode: 'adjustable', pageSizeOptions: [10,20,50] },
-    { mode: 'adjustable', defaultPageSize: 10 },
-    { mode: 'adjustable', defaultPageSize: 10, pageSizeOptions: [20,50] },
-    { mode: 'adjustable', defaultPageSize: 10, pageSizeOptions: [10,10,50] },
-    { mode: 'adjustable', defaultPageSize: 10, pageSizeOptions: [10,'20',50] },
-    { mode: 'adjustable', defaultPageSize: 10, pageSizeOptions: [10,0,50] },
-    { mode: 'adjustable', defaultPageSize: 10, pageSizeOptions: [10,20.5,50] },
-    { mode: 'adjustable', defaultPageSize: 0, pageSizeOptions: [0,20,50] },
-    { mode: 'adjustable', defaultPageSize: '10', pageSizeOptions: [10,20,50] },
-    { mode: 'adjustable', defaultPageSize: 10, pageSizeOptions: [10] },
-  ];
-  for (const value of cases) {
-    const inputs = parameters(structuredClone(index));
-    inputs.bindings.find(binding => binding.capabilityId === 'pagination').parameters = { ...value, minimumTestPages: 3 };
-    const checked = contract.checkCapabilities(inputs);
-    assert.equal(checked.status, 'failed', JSON.stringify(value));
-    assert.ok(checked.errors.some(error => /pagination/.test(error)));
-  }
-});
-
-test('user owns an offline editable copy and preparing again never overwrites it', t => {
-  const { directory, index, created } = fixture(t);
-  assert.equal(created, true);
-  assert.equal(index.templateId, 'admin-list');
-  assert.equal(contract.loadTemplate(directory).index.digest, index.digest);
-  edit(directory, html => html.replace('设备管理', '客户设备管理'));
-  contract.syncTemplate(directory);
-  const again = legacyFixture.prepareTemplate(contract, { project: path.resolve(directory, '../..') });
-  assert.equal(again.created, false);
-  assert.match(fs.readFileSync(path.join(directory, 'index.html'), 'utf8'), /客户设备管理/);
-  const html = fs.readFileSync(path.join(directory, 'index.html'), 'utf8');
-  assert.doesNotMatch(html, /<script[^>]+type=["']module|(?:src|href)=["'](?:https?:|\/\/)/i);
-  assert.doesNotMatch(fs.readFileSync(path.join(directory, 'assets/reference.js'), 'utf8'), /\bfetch\s*\(|\bimport\s/);
-});
-
-test('template or asset edits invalidate index, and synchronization is deterministic', t => {
-  const { directory, index } = fixture(t);
-  edit(directory, html => html.replace('设备管理', '新设备清单'));
-  assert.throws(() => contract.loadTemplate(directory), /stale|不同步/);
-  const readonly = contract.syncTemplate(directory, { write: false });
-  assert.notEqual(readonly.digest, index.digest);
-  assert.throws(() => contract.loadTemplate(directory), /stale|不同步/);
-  const updated = contract.syncTemplate(directory);
-  assert.equal(updated.digest, contract.syncTemplate(directory, { write: false }).digest);
-  fs.appendFileSync(path.join(directory, 'assets/reference.css'), '\n/* user style */');
-  assert.throws(() => contract.loadTemplate(directory), /stale|不同步/);
-  contract.syncTemplate(directory);
-  assert.ok(contract.loadTemplate(directory).files.every(file => file.encoding === 'base64'));
-});
-
-test('deleted pagination is detected from region mode even when its binding is deleted', t => {
-  const { index } = fixture(t);
-  const inputs = parameters(index);
-  inputs.bindings = inputs.bindings.filter(binding => binding.capabilityId !== 'pagination');
-  const result = contract.checkCapabilities(inputs);
-  assert.equal(result.status, 'failed');
-  assert.ok(result.errors.some(error => error.includes('pagination')));
-});
-
-test('required capability cannot be waived by an unsupported N/A or pending decision', t => {
-  const { index } = fixture(t);
-  const inputs = parameters(index);
-  const binding = index.bindings.find(entry => entry.capabilityId === 'pagination');
-  inputs.decisions = [{ bindingId: binding.id, status: 'not-applicable', reason: 'Prototype only' }];
-  assert.equal(contract.checkCapabilities(inputs).status, 'failed');
-  inputs.decisions[0].status = 'pending';
-  assert.equal(contract.checkCapabilities(inputs).status, 'failed');
-  inputs.decisions[0].status = 'not-applicable';
-  inputs.scope = {
-    requirements: [{ id: 'SCOPE-1', text: 'The user explicitly excluded pagination for this area', source: { type: 'scope-change', reference: 'user-message-12', statement: 'This area contains exactly one fixed record; omit paging.' } }],
-    exemptions: [{ pageId: binding.pageId, regionId: binding.regionId, capabilityId: 'pagination', requirementId: 'SCOPE-1', reason: 'Explicit scope change' }],
-  };
-  inputs.decisions[0].requirementId = 'SCOPE-1';
-  const result = contract.checkCapabilities(inputs);
-  assert.equal(result.status, 'passed', result.errors.join('\n'));
-  assert.ok(!result.requiredBindings.includes(binding.id));
-});
-
-test('each region needs its own capabilities and scenarios', t => {
-  const { index } = fixture(t);
-  const inputs = parameters(index);
-  const original = inputs.regions.find(region => region.mode === 'management-list');
-  inputs.regions.push({ ...original, id: 'second-list' });
-  const result = contract.checkCapabilities(inputs);
-  assert.equal(result.status, 'failed');
-  assert.ok(result.errors.some(error => error.includes('second-list/pagination')));
-});
-
-test('duplicate identity, unknown capability and unbound controls block sync without changing old index', t => {
-  const { directory } = fixture(t);
-  const initial = fs.readFileSync(path.join(directory, 'index.html'), 'utf8');
-  const indexBefore = fs.readFileSync(path.join(directory, 'capabilities.generated.json'), 'utf8');
-  for (const invalid of [
-    initial.replace('</main>', '<section data-page-id="devices"></section></main>'),
-    initial.replace('data-capability-id="pagination"', 'data-capability-id="unknown-widget"'),
-    initial.replace('</main>', '<button>Unmapped action</button></main>'),
-  ]) {
-    fs.writeFileSync(path.join(directory, 'index.html'), invalid);
-    assert.throws(() => contract.syncTemplate(directory), /identity|capability|interaction|身份|能力|交互/);
-    assert.equal(fs.readFileSync(path.join(directory, 'capabilities.generated.json'), 'utf8'), indexBefore);
-  }
-});
-
-test('missing behavior parameters and manually edited index are rejected', t => {
-  const { directory } = fixture(t);
-  const inputs = parameters(contract.loadTemplate(directory).index);
-  inputs.bindings.find(binding => binding.capabilityId === 'selection').parameters = {};
-  assert.equal(contract.checkCapabilities(inputs).status, 'failed');
-  const file = path.join(directory, 'capabilities.generated.json');
-  const edited = JSON.parse(fs.readFileSync(file, 'utf8'));
-  edited.bindings = edited.bindings.filter(binding => binding.capabilityId !== 'pagination');
-  fs.writeFileSync(file, JSON.stringify(edited));
-  assert.throws(() => contract.loadTemplate(directory), /stale|不同步/);
-});
-
-test('a frozen input snapshot is checked independently of current built-ins', t => {
-  const { directory, index } = fixture(t);
-  const inputRoot = path.join(directory, 'fixed-inputs');
-  fs.mkdirSync(inputRoot);
-  fs.writeFileSync(path.join(inputRoot, 'capabilities.json'), JSON.stringify(parameters(index)));
-  fs.writeFileSync(path.join(inputRoot, 'scope.json'), JSON.stringify({ requirements: [], exemptions: [] }));
-  assert.equal(contract.checkInstanceCapabilities(inputRoot).status, 'passed');
-  const frozen = JSON.parse(fs.readFileSync(path.join(inputRoot, 'capabilities.json'), 'utf8'));
-  frozen.bindings = frozen.bindings.filter(binding => binding.capabilityId !== 'pagination');
-  fs.writeFileSync(path.join(inputRoot, 'capabilities.json'), JSON.stringify(frozen));
-  assert.equal(contract.checkInstanceCapabilities(inputRoot).status, 'failed');
-});
-
-test('frozen template regions cannot disappear or change mode in the instance contract', t => {
-  const { directory } = fixture(t);
-  const snapshot = contract.loadTemplate(directory);
-  const inputRoot = path.join(directory, 'fixed-inputs');
-  fs.mkdirSync(inputRoot);
-  fs.writeFileSync(path.join(inputRoot, 'template-snapshot.json'), JSON.stringify(snapshot));
-  const fixed = parameters(snapshot.index);
-  fixed.regions = fixed.regions.filter(region => region.mode !== 'management-list');
-  fixed.bindings = fixed.bindings.filter(binding => binding.regionId !== 'device-list');
-  fs.writeFileSync(path.join(inputRoot, 'capabilities.json'), JSON.stringify(fixed));
-  assert.equal(contract.checkInstanceCapabilities(inputRoot).status, 'failed');
-});
-
-test('remote resources, module scripts and async loads cannot become offline templates', t => {
-  const { directory } = fixture(t);
-  const html = fs.readFileSync(path.join(directory, 'index.html'), 'utf8');
-  for (const invalid of [html.replace('src="assets/reference.js"', 'src="https://example.test/reference.js"'), html.replace('<script src=', '<script type="module" src=')]) {
-    fs.writeFileSync(path.join(directory, 'index.html'), invalid);
-    assert.throws(() => contract.syncTemplate(directory), /offline|离线/);
-  }
-  fs.writeFileSync(path.join(directory, 'index.html'), html);
-  fs.appendFileSync(path.join(directory, 'assets/reference.js'), '\nfetch("parts/table.html")');
-  assert.throws(() => contract.syncTemplate(directory), /offline|离线/);
-});
-
-test('unsafe identifiers and symlinked user template directories never write outside project', t => {
-  const project = fs.mkdtempSync(path.join(os.tmpdir(), 'i3-ui-template-path-'));
-  const other = fs.mkdtempSync(path.join(os.tmpdir(), 'i3-ui-template-other-'));
-  t.after(() => { fs.rmSync(project, { recursive: true, force: true }); fs.rmSync(other, { recursive: true, force: true }); });
-  assert.throws(() => legacyFixture.prepareTemplate(contract, { project, id: '../escape' }), /identifier|标识/);
-  fs.symlinkSync(other, path.join(project, 'ui-templates'), 'dir');
-  assert.throws(() => legacyFixture.prepareTemplate(contract, { project }), /symlink|符号链接/);
-  assert.deepEqual(fs.readdirSync(other), []);
-});
-
-test('content extraction reads visible headings, labels and button text with stable identities', t => {
-  const { directory }=fixture(t);
-  edit(directory,html=>html
-    .replace('<h1>设备管理</h1>','<h1>资产 &amp; 设备</h1>')
-    .replace('data-field-id="device-name">设备名称','data-field-id="device-name">设备显示名称')
-    .replace('设备名称 <span aria-label="必填">*','资产名称 <span aria-label="必填">*')
-    .replace('data-action-id="query" type="button">查询','data-action-id="query" type="button"><strong>检索设备</strong>'));
-  const index=contract.syncTemplate(directory);
-  assert.equal(index.pages[0].title,'资产 & 设备');
-  assert.equal(index.fields.find(item=>item.localId==='device-name').label,'设备显示名称');
-  assert.equal(index.fields.find(item=>item.localId==='edit-name').label,'资产名称');
-  assert.equal(index.fields.find(item=>item.localId==='query-status').label,'设备状态');
-  assert.equal(index.actions.find(item=>item.localId==='query').label,'检索设备');
-  const projected=contract.projectAdminListContent(contract.loadTemplate(directory));
-  assert.equal(projected.pageTitle,'资产 & 设备');
-  assert.equal(projected.fields.name.label,'设备显示名称');
-  assert.equal(projected.fields.editName.label,'资产名称');
-  assert.equal(projected.actions.query,'检索设备');
-});

package/scripts/ui-prototype-test.js

@@ -1,124 +0,0 @@
-'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 installationFile = path.join(__dirname, 'lib/installation.js');
-const skillsDirectory = fs.existsSync(installationFile) ? require(installationFile).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
-const lib = require(path.join(skillsDirectory, 'i3-ui-prototype/scripts/prototype-lib.cjs'));
-
-function fixture(t, template = 'classic-admin') {
-  const project = fs.mkdtempSync(path.join(os.tmpdir(), 'i3-ui-prototype-'));
-  t.after(() => fs.rmSync(project, { recursive: true, force: true }));
-  return lib.initPrototype({ project, id: 'approval-demo', template, expertMode: 'template' }).directory;
-}
-function json(dir, file) { return JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8')); }
-function write(dir, file, value) { fs.mkdirSync(path.dirname(path.join(dir, file)), { recursive: true }); fs.writeFileSync(path.join(dir, file), JSON.stringify(value, null, 2)); }
-function browserEvidence(dir) {
-  const revision = lib.contentManifest(dir);
-  fs.mkdirSync(path.join(dir, 'qa/screenshots'), { recursive: true });
-  fs.writeFileSync(path.join(dir, 'qa/screenshots/test.png'), Buffer.from('test evidence; not a real browser image'));
-  write(dir, 'qa/browser.json', { schemaVersion: 1, revision: revision.revision, digest: revision.digest, status: 'passed', source: 'isolated-test-fixture', screenshots: ['qa/screenshots/test.png'], journeys: [{ id: 'approval-flow', status: 'passed' }], consoleErrors: [], viewports: [1440, 768] });
-}
-test('default professional mode stops on missing dependency without writing a prototype', t => {
-  const project = fs.mkdtempSync(path.join(os.tmpdir(), 'i3-ui-missing-'));
-  t.after(() => fs.rmSync(project, { recursive: true, force: true }));
-  const result = lib.initPrototype({ project, id: 'example', providerRoots: [], discover: false });
-  assert.equal(result.status, 'needs-design-provider');
-  assert.deepEqual(result.choices.map(x => x.id), ['install', 'template', 'prepare']);
-  assert.equal(fs.existsSync(path.join(project, 'prototypes')), false);
-});
-test('template mode has an interactive runnable app and no expert usage claim', t => {
-  const dir = fixture(t);
-  const metadata = json(dir, 'prototype.json');
-  assert.equal(metadata.expertMode, 'template');
-  assert.equal(metadata.expert.status, 'skipped');
-  assert.equal(metadata.review.status, 'pending-review');
-  assert.equal(lib.checkPrototype(dir).status, 'passed');
-  assert.ok(fs.existsSync(path.join(dir, 'app/index.html')));
-  assert.throws(() => lib.initPrototype({ project: path.resolve(dir, '../..'), id: 'approval-demo', expertMode: 'template' }), /exists|已存在/);
-});
-test('all three legacy templates retain their distinct tokens and layouts', t => {
-  const values = lib.listTemplates({ legacy: true }).map(entry => {
-    const dir = fixture(t, entry.id);
-    assert.equal(lib.checkPrototype(dir).status, 'passed');
-    return { layout: json(dir, 'app/config.json').layout, primary: json(dir, 'design-system/tokens.json').semantic['color-primary'] };
-  });
-  assert.equal(values.length, 3);
-  assert.equal(new Set(values.map(v => v.layout)).size, 3);
-  assert.equal(new Set(values.map(v => v.primary)).size, 3);
-});
-test('baseline requires matching browser evidence and human confirmation, and is immutable', t => {
-  const dir = fixture(t);
-  const candidate = lib.contentManifest(dir);
-  assert.throws(() => lib.freezeBaseline(dir, { revision: candidate.revision, digest: candidate.digest, reviewer: 'Test reviewer', statement: 'Approved fixture', source: 'isolated-test' }), /browser|浏览器/);
-  browserEvidence(dir);
-  assert.throws(() => lib.freezeBaseline(dir, {}), /confirm|确认/);
-  const baseline = lib.freezeBaseline(dir, { revision: candidate.revision, digest: candidate.digest, reviewer: 'Test reviewer', statement: 'Approved fixture', source: 'isolated-test' });
-  assert.equal(baseline.digest, candidate.digest);
-  assert.throws(() => lib.freezeBaseline(dir, { revision: candidate.revision, digest: candidate.digest, reviewer: 'Test reviewer', statement: 'Approved fixture', source: 'isolated-test' }), /exists|已存在/);
-  const reviewFile = path.join(dir, 'baselines', candidate.revision, 'review.json');
-  const originalReview = fs.readFileSync(reviewFile);
-  const alteredReview = JSON.parse(originalReview); alteredReview.reviewer = 'Different reviewer';
-  fs.writeFileSync(reviewFile, JSON.stringify(alteredReview));
-  assert.equal(lib.compareBaseline(dir).status, 'corrupt-baseline');
-  fs.writeFileSync(reviewFile, originalReview);
-  fs.appendFileSync(path.join(dir, 'baselines', candidate.revision, 'app/styles.css'), '\n/* altered snapshot */');
-  assert.equal(lib.compareBaseline(dir).status, 'corrupt-baseline');
-});
-test('changed content invalidates old verification and cannot reuse old confirmation', t => {
-  const dir = fixture(t);
-  browserEvidence(dir);
-  const old = lib.contentManifest(dir);
-  fs.appendFileSync(path.join(dir, 'app/styles.css'), '\n/* modified */');
-  assert.throws(() => lib.freezeBaseline(dir, { revision: old.revision, digest: old.digest, reviewer: 'Test', statement: 'Approved', source: 'isolated-test' }), /matching|一致|changed|变化/);
-});
-test('iteration preserves baseline and identifies changes to design constraints', t => {
-  const dir = fixture(t);
-  browserEvidence(dir);
-  const current = lib.contentManifest(dir);
-  lib.freezeBaseline(dir, { revision: current.revision, digest: current.digest, reviewer: 'Test', statement: 'Approved fixture', source: 'isolated-test' });
-  lib.revisePrototype(dir, 'r002');
-  const tokens = json(dir, 'design-system/tokens.json');
-  tokens.semantic['color-primary'] = '#222222';
-  write(dir, 'design-system/tokens.json', tokens);
-  const result = lib.compareBaseline(dir);
-  assert.equal(result.status, 'changed');
-  assert.ok(result.protectedChanges.includes('design-system/tokens.json'));
-  assert.equal(json(dir, 'baseline.json').revision, 'r001');
-  assert.equal(json(dir, 'prototype.json').review.status, 'pending-review');
-});
-test('design token changes must be reflected in the actual runtime stylesheet', t => {
-  const dir = fixture(t);
-  const tokens = json(dir, 'design-system/tokens.json');
-  tokens.semantic['color-primary'] = '#222222';
-  write(dir, 'design-system/tokens.json', tokens);
-  assert.equal(lib.checkPrototype(dir).status, 'failed');
-});
-test('a manually created candidate cannot pass with an uncomputed template digest', t => {
-  const dir = fixture(t);
-  const metadata = json(dir, 'prototype.json');
-  metadata.template.digest = 'manual-init-uncomputed';
-  write(dir, 'prototype.json', metadata);
-  assert.equal(lib.checkPrototype(dir).status, 'failed');
-});
-test('unsafe identifiers and symlinked output parents are rejected before writes', t => {
-  const project = fs.mkdtempSync(path.join(os.tmpdir(), 'i3-ui-path-'));
-  const elsewhere = fs.mkdtempSync(path.join(os.tmpdir(), 'i3-ui-elsewhere-'));
-  t.after(() => { fs.rmSync(project, { recursive: true, force: true }); fs.rmSync(elsewhere, { recursive: true, force: true }); });
-  assert.throws(() => lib.initPrototype({ project, id: '../escape', expertMode: 'template' }), /identifier|标识/);
-  fs.symlinkSync(elsewhere, path.join(project, 'prototypes'), 'dir');
-  assert.throws(() => lib.initPrototype({ project, id: 'safe', expertMode: 'template' }), /symlink|符号链接/);
-  assert.deepEqual(fs.readdirSync(elsewhere), []);
-});
-test('a real review can reject every recommendation without inventing adoption at freeze', t => {
-  const dir=fixture(t); const metadata=json(dir,'prototype.json');
-  metadata.expertMode='professional'; metadata.expert={status:'reviewed'}; write(dir,'prototype.json',metadata);
-  write(dir,'qa/design-advice.json',{schemaVersion:1,mode:'professional',provider:{digest:'a'.repeat(64)},records:[{decision:'rejected',query:'targeted UX review',resultIdentity:'unit-fixture-result',rationale:'Fixture is intentionally incompatible with locked design',verification:'Reviewed against fixture contract'}]});
-  browserEvidence(dir);
-  const current=lib.contentManifest(dir);
-  assert.equal(lib.checkPrototype(dir,{acceptance:true}).status,'passed');
-  lib.freezeBaseline(dir,{revision:current.revision,digest:current.digest,reviewer:'Fixture reviewer',statement:'Isolated guard test only',source:'unit-test-fixture'});
-  assert.equal(json(dir,'prototype.json').expert.status,'reviewed');
-});

package/scripts/ui-prototype-transcript-auto-test.js

@@ -1,67 +0,0 @@
-'use strict';
-// Synthetic files and in-memory configuration only; never installs or launches a host.
-const fs=require('node:fs'),path=require('node:path'),os=require('node:os'),test=require('node:test'),assert=require('node:assert/strict');
-const prototypeScripts=(()=>{const file=path.join(__dirname,'lib/installation.js');return path.join(fs.existsSync(file)?require(file).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');})();
-const E=require(prototypeScripts+'/execution-evidence.cjs'),C=require(prototypeScripts+'/codebuddy-context.cjs'),R=require(prototypeScripts+'/codebuddy-registration.cjs');
-function fixture(t) {
- const root=fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(),'i3-transcript-contract-'))),project=path.join(root,'business'),native=path.join(root,'native');
- fs.mkdirSync(project);fs.mkdirSync(native);t.after(()=>fs.rmSync(root,{recursive:true,force:true}));
- const rows=[{type:'user',sessionId:'session-a',message:{content:'生成当前原型'}},{type:'assistant',sessionId:'session-a',message:{content:[{type:'tool_use',id:'front-1',name:'Skill',input:{skill:'i3-frontend-ui-engineering'}}]}},{type:'user',sessionId:'session-a',message:{content:[{type:'tool_result',tool_use_id:'front-1',content:'Native fixture instructions'}]}}];
- const file=path.join(native,'session.txt');fs.writeFileSync(file,rows.map(JSON.stringify).join('\n')+'\n');return {root,project,native,file,rows};
-}
-test('new IDE and CLI registrations default to automatic transcripts in both scopes',()=>{
- for(const product of ['ide','cli'])for(const scope of ['project','global']) {
-  const base=scope==='project'?'/work/p/.codebuddy':'/users/u/.codebuddy';
-  const change=R.plan({action:'enable',product,scope,base,project:'/work/p',nodePath:'/node',scriptPath:base+'/hooks/i3-prototype.cjs',scriptDigest:'a'.repeat(64)});
-  assert.equal(change.recordAfter.transcriptMode,'auto');assert.deepEqual(change.recordAfter.transcriptRoots,[]);
- }
-});
-test('manual and legacy root restrictions are retained; empty manual policy is rejected',()=>{
- const options={action:'enable',product:'ide',scope:'project',base:'/work/p/.codebuddy',project:'/work/p',nodePath:'/node',scriptPath:'/fixed/hook.cjs',scriptDigest:'a'.repeat(64),transcriptRoots:['/native/logs']};
- const first=R.plan(options);assert.equal(first.recordAfter.transcriptMode,'manual');
- const legacy=structuredClone(first.recordAfter);delete legacy.transcriptMode;
- const kept=R.plan({...options,action:'keep',transcriptRoots:undefined,currentText:first.afterText,record:legacy});
- assert.equal(kept.recordAfter.transcriptMode,'manual');assert.deepEqual(kept.recordAfter.transcriptRoots,['/native/logs']);
- assert.throws(()=>R.plan({...options,transcriptMode:'manual',transcriptRoots:[]}),/manual|roots/i);
-});
-test('automatic source uses the exact callback file regardless of filename suffix',t=>{
- const f=fixture(t),payload={transcript_path:f.file,session_id:'session-a'};
- const source=C.source(payload,{transcriptMode:'auto',transcriptRoots:[]},f.project);
- assert.equal(source.path,f.file);assert.equal(E.loaded(source.calls,'frontend').length,1);assert.equal(source.tamperProof,false);
- assert.equal(source.sourceVerification,'native-hook-transcript');
-});
-test('automatic discovery never admits business files, leaf symlinks or missing files',t=>{
- const f=fixture(t),record={transcriptMode:'auto',transcriptRoots:[]},load=file=>C.source({transcript_path:file,session_id:'session-a'},record,f.project);
- const fake=path.join(f.project,'qa.jsonl');fs.copyFileSync(f.file,fake);assert.throws(()=>load(fake),/business project/i);
- const alias=path.join(f.native,'alias.jsonl');fs.symlinkSync(f.file,alias);assert.throws(()=>load(alias),/symlink|native transcript/i);
- assert.throws(()=>load(path.join(f.native,'missing.jsonl')),/not.*available|ENOENT/i);
- assert.throws(()=>load('relative.jsonl'),/absolute|native transcript/i);
-});
-test('automatic source still rejects malformed streams, forged declarations and mismatched sessions',t=>{
- const f=fixture(t),record={transcriptMode:'auto',transcriptRoots:[]},payload={transcript_path:f.file,session_id:'different'};
- assert.throws(()=>C.source(payload,record,f.project),/session/i);
- payload.session_id='session-a';
- for(const content of ['plain transcript text','{"skill":"frontend","passed":true}\n','{"type":"assistant","message":{"content":[]}}\n']) {
-  fs.writeFileSync(f.file,content);assert.throws(()=>C.source(payload,record,f.project),/JSONL|native|Native|user task/);
- }
-});
-test('manual roots remain enforced even when a valid callback points elsewhere',t=>{
- const f=fixture(t),record={transcriptMode:'manual',transcriptRoots:[path.join(f.root,'other')]};
- assert.throws(()=>C.source({transcript_path:f.file,session_id:'session-a'},record,f.project),/outside.*roots/);
- record.transcriptRoots=[f.native];assert.equal(C.source({transcript_path:f.file,session_id:'session-a'},record,f.project).path,f.file);
-});
-test('automatic reading refuses oversized native files without parsing their contents',t=>{
- const f=fixture(t);fs.truncateSync(f.file,64*1024*1024+1);
- assert.throws(()=>C.source({transcript_path:f.file,session_id:'session-a'},{transcriptMode:'auto',transcriptRoots:[]},f.project),/oversized|native transcript/i);
-});
-test('unreadable native transcripts cannot become valid evidence',t=>{
- const f=fixture(t);fs.chmodSync(f.file,0);
- try{assert.throws(()=>C.source({transcript_path:f.file,session_id:'session-a'},{transcriptMode:'auto',transcriptRoots:[]},f.project),/EACCES|EPERM/);}
- finally{fs.chmodSync(f.file,0o600);}
-});
-test('missing callback identity and contradictory policy cannot fall back to another log',t=>{
- const f=fixture(t),record={transcriptMode:'auto',transcriptRoots:[]};
- assert.throws(()=>C.source({session_id:'session-a'},record,f.project),/fields required/);
- assert.throws(()=>C.source({transcript_path:f.file},record,f.project),/fields required/);
- assert.throws(()=>C.source({transcript_path:f.file,session_id:'session-a'},{...record,transcriptRoots:[f.native]},f.project),/manual roots/);
-});