@givolt/i3-composer-agent 3.2.1 → 4.0.0

package/scripts/prototype-locations-test.js

@@ -1,79 +0,0 @@
-'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

@@ -1,183 +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 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);
-});

package/scripts/template-adapter-test.js

@@ -1,155 +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 crypto = require('node:crypto');
-const installation = path.join(__dirname, 'lib/installation.js');
-const skills = fs.existsSync(installation) ? require(installation).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
-const skill = path.join(skills, 'i3-ui-prototype');
-const lib = require(path.join(skill, 'scripts/prototype-lib.cjs'));
-const { createTemplateRegistry } = require(path.join(skill, 'scripts/template-adapters.cjs'));
-const read = (root, file) => JSON.parse(fs.readFileSync(path.join(root, file), 'utf8'));
-function write(root, file, value) {
-  fs.mkdirSync(path.dirname(path.join(root, file)), { recursive: true });
-  fs.writeFileSync(path.join(root, file), typeof value === 'string' ? value : JSON.stringify(value, null, 2));
-}
-function fixture(t) {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'template-adapter-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const assets = path.join(root, 'assets'), project = path.join(root, 'project');
-  fs.mkdirSync(project);
-  write(assets, 'catalog.json', { schemaVersion: 2, defaultTemplate: 'independent-demo', templates: [
-    { id: 'independent-demo', name: 'Independent test fixture', version: '1.0.0', availability: 'available', manifest: 'independent-demo/manifest.json' },
-    { id: 'not-built', name: 'Planned fixture', version: null, availability: 'planned' },
-  ], legacyTemplates: [] });
-  write(assets, 'independent-demo/manifest.json', { schemaVersion: 1, adapter: 'independent-test', preset: 'independent-demo/preset.json', resources: { root: 'independent-demo/runtime' }, defaultTitle: 'Independent fixture' });
-  write(assets, 'independent-demo/preset.json', { layout: 'independent', primitive: {}, semantic: { 'color-primary': '#123456' }, component: {} });
-  write(assets, 'independent-demo/runtime/index.html', '<!doctype html><title>Independent fixture</title><main>Independent runtime</main>');
-  write(assets, 'independent-demo/runtime/unique.txt', 'INDEPENDENT RUNTIME');
-  const adapter = {
-    version: 'test-fixture-1',
-    runtime: { kind: 'independent-test', requiredFiles: ['app/unique.txt'], identityFields: ['runtime'], excludedBrowserPrefixes: [], protectedFiles: ['app/unique.txt'], protectedDirectories: [] },
-    fingerprintInputs: ({ resources }) => [resources.root],
-    initialize(directory, options, context) {
-      fs.cpSync(context.resource('root'), path.join(directory, 'app'), { recursive: true });
-      fs.mkdirSync(path.join(directory, 'mocks'));
-      write(directory, 'design-system/MASTER.md', '# Independent design');
-      write(directory, 'requirements-map.json', { schemaVersion: 1, requirements: [{ id: 'ONLY-01', pages: ['app/index.html'], roles: ['test'], actions: ['read'], scenarios: ['independent-flow'] }] });
-      return { metadata: { runtime: { kind: 'independent-test', entry: 'app/index.html' } }, handoff: 'Independent test fixture only.' };
-    },
-    validateRuntime(metadata) { assert.equal(metadata.runtime?.kind, 'independent-test'); },
-  };
-  const registry = () => createTemplateRegistry({ assetRoot: assets, adapters: { 'independent-test': adapter } });
-  return { assets, project, registry, adapter };
-}
-test('a registered independent runtime initializes and validates without any common assets', t => {
-  const f = fixture(t), registry = f.registry();
-  const result = lib.initPrototype({ project: f.project, id: 'standalone', expertMode: 'template' }, registry);
-  assert.equal(result.status, 'created');
-  assert.equal(fs.existsSync(path.join(f.assets, 'common')), false);
-  assert.equal(fs.readFileSync(path.join(result.directory, 'app/unique.txt'), 'utf8'), 'INDEPENDENT RUNTIME');
-  assert.equal(read(result.directory, 'prototype.json').template.adapter, 'independent-test');
-  const checked = lib.checkPrototype(result.directory, {}, registry);
-  assert.equal(checked.status, 'passed', JSON.stringify(checked));
-  fs.unlinkSync(path.join(result.directory, 'app/unique.txt'));
-  assert.match(lib.checkPrototype(result.directory, {}, registry).errors.join(' '), /unique\.txt/);
-});
-test('planned, unknown and unregistered adapters fail before touching the output project', t => {
-  const f = fixture(t);
-  assert.throws(() => lib.initPrototype({ project: f.project, id: 'planned', template: 'not-built', expertMode: 'template' }, f.registry()), /planned|尚未/);
-  assert.deepEqual(fs.readdirSync(f.project), []);
-  const manifest = read(f.assets, 'independent-demo/manifest.json');
-  manifest.adapter = 'missing-adapter'; write(f.assets, 'independent-demo/manifest.json', manifest);
-  assert.throws(() => lib.initPrototype({ project: f.project, id: 'unknown', expertMode: 'template' }, f.registry()), /adapter/i);
-  assert.deepEqual(fs.readdirSync(f.project), []);
-});
-test('catalog and manifest paths reject traversal, absolute paths and symlinks before writes', t => {
-  for (const unsafe of ['../outside', '/tmp/outside', 'C:\\outside', 'independent-demo/../outside']) {
-    const f = fixture(t), manifest = read(f.assets, 'independent-demo/manifest.json');
-    manifest.resources.root = unsafe; write(f.assets, 'independent-demo/manifest.json', manifest);
-    assert.throws(() => lib.initPrototype({ project: f.project, id: 'unsafe', expertMode: 'template' }, f.registry()), /path|路径|outside|inside|unsafe/i);
-    assert.deepEqual(fs.readdirSync(f.project), []);
-  }
-  const f = fixture(t), manifest = read(f.assets, 'independent-demo/manifest.json');
-  fs.symlinkSync(path.join(f.assets, 'independent-demo/runtime'), path.join(f.assets, 'linked'), 'dir');
-  manifest.resources.root = 'linked'; write(f.assets, 'independent-demo/manifest.json', manifest);
-  assert.throws(() => lib.initPrototype({ project: f.project, id: 'linked', expertMode: 'template' }, f.registry()), /symlink|符号链接/i);
-  assert.deepEqual(fs.readdirSync(f.project), []);
-});
-test('duplicate catalog identities and unsafe manifest locations cannot alias another template', t => {
-  const f = fixture(t), catalog = read(f.assets, 'catalog.json');
-  catalog.legacyTemplates.push({ ...catalog.templates[0] }); write(f.assets, 'catalog.json', catalog);
-  assert.throws(() => f.registry().list(), /duplicate|重复/i);
-  catalog.legacyTemplates = []; catalog.templates[0].manifest = '../manifest.json'; write(f.assets, 'catalog.json', catalog);
-  assert.throws(() => f.registry().list(), /path|路径|manifest/i);
-});
-test('independent runtime and manifest changes are included in the template fingerprint', t => {
-  const f = fixture(t), original = f.registry().list()[0].digest;
-  fs.appendFileSync(path.join(f.assets, 'independent-demo/runtime/unique.txt'), '\nchanged');
-  const changedRuntime = f.registry().list()[0].digest;
-  assert.notEqual(changedRuntime, original);
-  const manifest = read(f.assets, 'independent-demo/manifest.json');
-  manifest.defaultTitle = 'Changed default title'; write(f.assets, 'independent-demo/manifest.json', manifest);
-  assert.notEqual(f.registry().list()[0].digest, changedRuntime);
-});
-test('adapter versions and declared implementation files participate in template fingerprints', t => {
-  const f = fixture(t), initial = f.registry().list()[0].digest;
-  f.adapter.version = 'test-fixture-2';
-  assert.notEqual(f.registry().list()[0].digest, initial);
-  const implementation = path.join(f.assets, 'adapter-fixture.cjs');
-  fs.writeFileSync(implementation, '// fixture adapter implementation v1');
-  f.adapter.implementationFiles = [implementation];
-  const before = f.registry().list()[0].digest;
-  fs.writeFileSync(implementation, '// fixture adapter implementation v2');
-  assert.notEqual(f.registry().list()[0].digest, before);
-});
-test('selected catalog metadata affects fingerprints without coupling unrelated templates', t => {
-  const f = fixture(t), original = f.registry().resolve('independent-demo').entry.digest;
-  const catalog = read(f.assets, 'catalog.json');
-  catalog.templates[0].name = 'Renamed independent fixture'; write(f.assets, 'catalog.json', catalog);
-  const renamed = f.registry().resolve('independent-demo').entry.digest;
-  assert.notEqual(renamed, original);
-  catalog.templates[1].name = 'Renamed unrelated planned fixture'; write(f.assets, 'catalog.json', catalog);
-  assert.equal(f.registry().resolve('independent-demo').entry.digest, renamed);
-});
-test('baseline guards use independent adapter protected paths and reject runtime substitution', t => {
-  const f = fixture(t), registry = f.registry();
-  const dir = lib.initPrototype({ project: f.project, id: 'baseline', expertMode: 'template' }, registry).directory;
-  const manifest = lib.contentManifest(dir, registry);
-  write(dir, 'qa/unit-fixture.txt', 'UNIT FIXTURE ONLY; not browser evidence or human approval');
-  write(dir, 'qa/browser.json', { revision: manifest.revision, digest: manifest.digest, status: 'passed', source: 'UNIT FIXTURE ONLY', screenshots: ['qa/unit-fixture.txt'], journeys: [{ id: 'independent-flow', status: 'passed' }], consoleErrors: [], viewports: [390, 1440] });
-  lib.freezeBaseline(dir, { revision: manifest.revision, digest: manifest.digest, reviewer: 'unit fixture', statement: 'UNIT FIXTURE ONLY', source: 'test fixture' }, registry);
-  fs.appendFileSync(path.join(dir, 'app/unique.txt'), '\nchanged');
-  assert.ok(lib.compareBaseline(dir, registry).protectedChanges.includes('app/unique.txt'));
-  fs.appendFileSync(path.join(dir, 'design-system/MASTER.md'), '\nchanged design contract');
-  assert.ok(lib.compareBaseline(dir, registry).protectedChanges.includes('design-system/MASTER.md'));
-  const identityChange = read(dir, 'prototype.json');
-  identityChange.runtime.variant = 'changed'; write(dir, 'prototype.json', identityChange);
-  assert.ok(lib.compareBaseline(dir, registry).protectedChanges.includes('runtime-contract'));
-  const metadata = read(dir, 'prototype.json'); metadata.template.adapter = 'legacy-html'; write(dir, 'prototype.json', metadata);
-  assert.equal(lib.checkPrototype(dir, {}, registry).status, 'failed');
-});
-test('pre-adapter legacy instances retain their original manifest digest and remain inspectable', t => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'legacy-adapter-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const dir = lib.initPrototype({ project: root, id: 'old-legacy', template: 'classic-admin', expertMode: 'template' }).directory;
-  const metadata = read(dir, 'prototype.json'); delete metadata.template.adapter; delete metadata.runtime; write(dir, 'prototype.json', metadata);
-  const identity = { id: metadata.id, revision: metadata.revision, template: metadata.template, expertMode: metadata.expertMode, artifactKind: metadata.artifactKind };
-  const manifest = lib.contentManifest(dir);
-  assert.deepEqual(manifest.identity, identity);
-  assert.equal(manifest.digest, crypto.createHash('sha256').update(JSON.stringify({ identity, files: manifest.files })).digest('hex'));
-  assert.equal(lib.checkPrototype(dir).status, 'passed');
-});
-test('pre-adapter EASEL identities keep the previous content-manifest field order and digest', t => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'old-easel-adapter-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const dir = lib.initPrototype({ project: root, id: 'old-easel', purpose: 'template-review', expertMode: 'template' }).directory;
-  const metadata = read(dir, 'prototype.json'); delete metadata.template.adapter; write(dir, 'prototype.json', metadata);
-  const identity = { id: metadata.id, revision: metadata.revision, template: metadata.template, expertMode: metadata.expertMode, artifactKind: metadata.artifactKind, purpose: metadata.purpose, business: metadata.business, runtime: metadata.runtime };
-  const manifest = lib.contentManifest(dir);
-  assert.equal(JSON.stringify(manifest.identity), JSON.stringify(identity));
-  assert.equal(manifest.digest, crypto.createHash('sha256').update(JSON.stringify({ identity, files: manifest.files })).digest('hex'));
-  assert.equal(lib.checkPrototype(dir).status, 'passed');
-});

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

@@ -1,84 +0,0 @@
-'use strict';
-// Regression cases reduced from a real IDE failure; no native host is installed.
-const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs'),path=require('node:path'),os=require('node:os'),cp=require('node:child_process');
-const installed=path.join(__dirname,'lib/installation.js');
-const scripts=path.join(fs.existsSync(installed)?require(installed).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');
-const E=require(path.join(scripts,'execution-evidence.cjs')),H=require(path.join(scripts,'codebuddy-hook.cjs')),N=require(path.join(scripts,'native-command.cjs')),R=require(path.join(scripts,'execution-recovery.cjs'));
-const raw=rows=>rows.map(row=>JSON.stringify(row)).join('\n')+'\n';
-for(const flat of [false,true])test(`raw ${flat?'flat':'paired'} use_skill is a real Skill without accepting Read or forged names`,()=>{
- const rows=flat?[
-  {type:'function_call',callId:'front',name:'use_skill',arguments:'{"command":"i3-frontend-ui-engineering"}',sessionId:'s1'},
-  {type:'function_call_result',callId:'front',name:'Skill',status:'completed',output:'Frontend instructions',sessionId:'s1'}
- ]:[
-  {type:'assistant',sessionId:'s1',message:{content:[{type:'tool_use',id:'front',name:'use_skill',input:{command:'i3-frontend-ui-engineering'}}]}},
-  {type:'user',sessionId:'s1',message:{content:[{type:'tool_result',tool_use_id:'front',tool_name:'Skill',content:'Frontend instructions'}]}}
- ];
- const calls=E.parse(raw(rows));assert.equal(E.loaded(calls,'frontend').length,1);assert.equal(calls[0].name,'Skill');assert.equal(calls[0].rawName,'use_skill');
- assert.equal(H.eventCall({hook_event_name:'PostToolUse',tool_name:'use_skill',tool_use_id:'front',tool_input:calls[0].input},{prompts:[{line:0}],calls}).toolCallId,'front');
- for(const name of ['Read','use_skill_fake']){
-  const changed=JSON.parse(JSON.stringify(rows));if(flat){changed[0].name=changed[1].name=name;}else{changed[0].message.content[0].name=changed[1].message.content[0].tool_name=name;}
-  assert.equal(E.loaded(E.parse(raw(changed)),'frontend').length,0);
- }
- const wrong=JSON.parse(JSON.stringify(rows));if(flat)wrong[1].sessionId='s2';else wrong[1].sessionId='s2';assert.throws(()=>E.parse(raw(wrong)),/session/);
-});
-test('native execute_command success cannot hide a failed stage inside result or stdout',()=>{
- for(const result of [
-  {type:'execute_command_result',exitCode:1,stdout:'failed'},
-  {type:'execute_command_result',exitCode:0,stdout:'{"status":"failed","errors":["No native Hook task binding"]}\r\n\r\n'},
-  {type:'execute_command_result',exitCode:0,stdout:'Error: unavailable'},
-  {status:'failed',errors:['native stage failed']}
- ])assert.equal(E.successful({content:{status:'success',success:true,result}}),false);
- assert.equal(E.successful({content:{status:'success',success:true,result:{type:'execute_command_result',exitCode:0,stdout:'{"status":"bound","runId":"r1"}'}}}),true);
- assert.equal(E.successful({content:{result:{status:'failed'},observedApplicationState:true}}),true,'A browser observation of an error is not a failed tool');
-});
-test('frontend already loaded leaves only execution-begin missing until the native begin actually succeeds',()=>{
- const directory='/work/prototypes/a',binding={entryLine:1,contextLine:0,sessionId:'s1',runId:'r1',directory,project:'/work'};
- const source={prompts:[{line:1,text:'实现原型'}],contextLine:0,calls:[{skill:'frontend',success:true,sessionId:'s1',requestLine:2,resultLine:3}]};
- const input={event:'PreToolUse',source,binding,tool:'Write',input:{file_path:directory+'/app/src/A.vue'},directory,cwd:'/work'};
- let answer=H.decision(input);assert.equal(answer.deny,true);assert.deepEqual(answer.missing,['execution-begin']);assert.doesNotMatch(answer.reason,/调用 i3-frontend/);
- const command=`node /skills/native-pilot.cjs execution-begin '${directory}'`;
- const begin={toolCallId:'begin',name:'Bash',input:{command},cwd:'/work',success:false,sessionId:'s1',result:{status:'bound',runId:'r1',sessionId:'s1',directory},requestLine:4,resultLine:5};source.calls.push(begin);
- assert.equal(H.decision(input).deny,true);begin.success=true;assert.equal(H.decision(input).continue,true);
- begin.result={...begin.result,runId:'another-run'};assert.equal(H.decision(input).deny,true);begin.result.runId='r1';
- begin.result.status='success';assert.equal(H.decision(input).deny,true);begin.result.status='bound';
- source.stableThroughLine=4;assert.equal(H.decision(input).deny,true);delete source.stableThroughLine;
- source.calls.push({...begin,toolCallId:'failed-rebind',requestLine:6,resultLine:7,success:false});assert.equal(H.decision(input).deny,true,'A failed rebind must not inherit old success');
-});
-test('binding recovery emits one absolute quoted command that the strict parser recognizes',()=>{
- const directory="/work with spaces/prototypes/customer's demo";
- const command=N.beginCommand(directory);const parsed=N.nativeCommand('Bash',{command},'/unrelated');
- assert.equal(parsed.operation,'execution-begin');assert.equal(parsed.root,directory);assert.ok(path.isAbsolute(parsed.argv[0]));assert.ok(path.isAbsolute(parsed.argv[1]));
- assert.match(R.instruction(['execution-begin'],{directory}),new RegExp('execution-begin'));assert.ok(R.instruction(['execution-begin'],{directory}).includes(command));
- assert.match(R.instruction(['execution-begin'],{directory}),/管道|pipeline/);
- assert.equal(N.nativeCommand('Bash',{command:`cd /work && ${command} 2>&1 | head -80`},'/work'),null);
-});
-test('unbound CLI execution-begin exits nonzero with an actionable standalone command and creates no proof',t=>{
- const root=fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(),'i3-unbound-regression-')));t.after(()=>fs.rmSync(root,{recursive:true,force:true}));
- const result=cp.spawnSync(process.execPath,[path.join(scripts,'native-pilot.cjs'),'execution-begin',root],{encoding:'utf8'});
- assert.equal(result.status,1);const failure=JSON.parse(result.stderr);assert.equal(failure.status,'failed');assert.match(failure.errors.join(),/No native Hook task binding/);
- assert.ok(failure.errors.join().includes(N.beginCommand(root)));assert.deepEqual(fs.readdirSync(root),[]);
-});
-test('PostToolUse failures use additionalContext and keep the tool return intact',()=>{
- const value=require(path.join(scripts,'hosts/codebuddy.cjs')).format({feedback:true,reason:'实际返回失败，请补调'},'PostToolUse');
- assert.equal(value.output.continue,true);assert.deepEqual(value.output.hookSpecificOutput,{hookEventName:'PostToolUse',additionalContext:'实际返回失败，请补调'});
- const bound={status:'bound',runId:'r1'};assert.deepEqual(E.resultValue([{type:'text',text:JSON.stringify(bound)}]),bound);
-});
-test('native wrappers preserve actual JSON facts and quoted findings without matching escaped wrapper bytes',()=>{
- const facts={form:{errors:1},observed:true},wrapped={status:'success',success:true,result:JSON.stringify(facts)};
- const A=require(path.join(scripts,'execution-assertions.cjs'));
- assert.equal(A.extract(A.resultData(wrapped),'/form/errors'),1);assert.ok(E.resultText(wrapped).includes('"observed":true'));
- assert.deepEqual(A.resultData({result:{status:'failed'},observedApplicationState:true}),{result:{status:'failed'},observedApplicationState:true});
- assert.equal(E.successful({content:{type:'text',text:'{"status":"failed","operation":"execution-begin"}'}}),false);
-});
-test('loading a missing browser Skill cannot let another stage stand in for the denied finalize retry',()=>{
- const source={prompts:[{line:1,digest:'task',text:'实现原型'}],contextLine:0,calls:[]},index={};
- const context={source,sessionId:'s1',directory:'/work/prototypes/a',stage:'delivery',event:'PreToolUse',eventKey:'deny-finalize',expectedRetry:{kind:'stage',stage:'delivery',operation:'finalize'}};
- R.record(index,context,{deny:true,missing:['browser']});
- source.calls.push({skill:'browser',toolCallId:'actual-browser-load',sessionId:'s1',requestLine:2,resultLine:3,success:true});
- const failedPrerequisite=R.record(index,{...context,stage:'browser-entry',event:'PostToolUse',eventKey:'failed-review',expectedRetry:{kind:'stage',stage:'browser-entry',operation:'record-devtools-review'}},{feedback:true,missing:['execution-evidence']});
- assert.equal(failedPrerequisite.recovery.expectedRetry.operation,'finalize');
- const other=R.record(index,{...context,stage:'browser-entry',resolved:['execution-evidence'],event:'PostToolUse',eventKey:'other-stage-result',retrySucceeded:true,retry:{kind:'stage',stage:'browser-entry',operation:'record-devtools-review',requestLine:4,resultLine:5}},{continue:true});
- assert.equal(other.recovery.status,'ready-to-retry');
- const correct=R.record(index,{...context,event:'PostToolUse',eventKey:'finalize-result',retrySucceeded:true,retry:{kind:'stage',stage:'delivery',operation:'finalize',requestLine:6,resultLine:7}},{continue:true});
- assert.equal(correct.recovery.status,'recovered');
-});