aw-ecc 1.4.21

package/scripts/lib/install-state.js

@@ -0,0 +1,313 @@
+const fs = require('fs');
+const path = require('path');
+
+let Ajv = null;
+try {
+  // Prefer schema-backed validation when dependencies are installed.
+  // The fallback validator below keeps source checkouts usable in bare environments.
+  const ajvModule = require('ajv');
+  Ajv = ajvModule.default || ajvModule;
+} catch (_error) {
+  Ajv = null;
+}
+
+const SCHEMA_PATH = path.join(__dirname, '..', '..', 'schemas', 'install-state.schema.json');
+
+let cachedValidator = null;
+
+function cloneJsonValue(value) {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  return JSON.parse(JSON.stringify(value));
+}
+
+function readJson(filePath, label) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (error) {
+    throw new Error(`Failed to read ${label}: ${error.message}`);
+  }
+}
+
+function getValidator() {
+  if (cachedValidator) {
+    return cachedValidator;
+  }
+
+  if (Ajv) {
+    const schema = readJson(SCHEMA_PATH, 'install-state schema');
+    const ajv = new Ajv({ allErrors: true });
+    cachedValidator = ajv.compile(schema);
+    return cachedValidator;
+  }
+
+  cachedValidator = createFallbackValidator();
+  return cachedValidator;
+}
+
+function createFallbackValidator() {
+  const validate = state => {
+    const errors = [];
+    validate.errors = errors;
+
+    function pushError(instancePath, message) {
+      errors.push({
+        instancePath,
+        message,
+      });
+    }
+
+    function isNonEmptyString(value) {
+      return typeof value === 'string' && value.length > 0;
+    }
+
+    function validateNoAdditionalProperties(value, instancePath, allowedKeys) {
+      for (const key of Object.keys(value)) {
+        if (!allowedKeys.includes(key)) {
+          pushError(`${instancePath}/${key}`, 'must NOT have additional properties');
+        }
+      }
+    }
+
+    function validateStringArray(value, instancePath) {
+      if (!Array.isArray(value)) {
+        pushError(instancePath, 'must be array');
+        return;
+      }
+
+      for (let index = 0; index < value.length; index += 1) {
+        if (!isNonEmptyString(value[index])) {
+          pushError(`${instancePath}/${index}`, 'must be non-empty string');
+        }
+      }
+    }
+
+    function validateOptionalString(value, instancePath) {
+      if (value !== undefined && value !== null && !isNonEmptyString(value)) {
+        pushError(instancePath, 'must be string or null');
+      }
+    }
+
+    if (!state || typeof state !== 'object' || Array.isArray(state)) {
+      pushError('/', 'must be object');
+      return false;
+    }
+
+    validateNoAdditionalProperties(
+      state,
+      '',
+      ['schemaVersion', 'installedAt', 'lastValidatedAt', 'target', 'request', 'resolution', 'source', 'operations']
+    );
+
+    if (state.schemaVersion !== 'ecc.install.v1') {
+      pushError('/schemaVersion', 'must equal ecc.install.v1');
+    }
+
+    if (!isNonEmptyString(state.installedAt)) {
+      pushError('/installedAt', 'must be non-empty string');
+    }
+
+    if (state.lastValidatedAt !== undefined && !isNonEmptyString(state.lastValidatedAt)) {
+      pushError('/lastValidatedAt', 'must be non-empty string');
+    }
+
+    const target = state.target;
+    if (!target || typeof target !== 'object' || Array.isArray(target)) {
+      pushError('/target', 'must be object');
+    } else {
+      validateNoAdditionalProperties(target, '/target', ['id', 'target', 'kind', 'root', 'installStatePath']);
+      if (!isNonEmptyString(target.id)) {
+        pushError('/target/id', 'must be non-empty string');
+      }
+      validateOptionalString(target.target, '/target/target');
+      if (target.kind !== undefined && !['home', 'project'].includes(target.kind)) {
+        pushError('/target/kind', 'must be equal to one of the allowed values');
+      }
+      if (!isNonEmptyString(target.root)) {
+        pushError('/target/root', 'must be non-empty string');
+      }
+      if (!isNonEmptyString(target.installStatePath)) {
+        pushError('/target/installStatePath', 'must be non-empty string');
+      }
+    }
+
+    const request = state.request;
+    if (!request || typeof request !== 'object' || Array.isArray(request)) {
+      pushError('/request', 'must be object');
+    } else {
+      validateNoAdditionalProperties(
+        request,
+        '/request',
+        ['profile', 'modules', 'includeComponents', 'excludeComponents', 'legacyLanguages', 'legacyMode']
+      );
+      if (!(Object.prototype.hasOwnProperty.call(request, 'profile') && (request.profile === null || typeof request.profile === 'string'))) {
+        pushError('/request/profile', 'must be string or null');
+      }
+      validateStringArray(request.modules, '/request/modules');
+      validateStringArray(request.includeComponents, '/request/includeComponents');
+      validateStringArray(request.excludeComponents, '/request/excludeComponents');
+      validateStringArray(request.legacyLanguages, '/request/legacyLanguages');
+      if (typeof request.legacyMode !== 'boolean') {
+        pushError('/request/legacyMode', 'must be boolean');
+      }
+    }
+
+    const resolution = state.resolution;
+    if (!resolution || typeof resolution !== 'object' || Array.isArray(resolution)) {
+      pushError('/resolution', 'must be object');
+    } else {
+      validateNoAdditionalProperties(resolution, '/resolution', ['selectedModules', 'skippedModules']);
+      validateStringArray(resolution.selectedModules, '/resolution/selectedModules');
+      validateStringArray(resolution.skippedModules, '/resolution/skippedModules');
+    }
+
+    const source = state.source;
+    if (!source || typeof source !== 'object' || Array.isArray(source)) {
+      pushError('/source', 'must be object');
+    } else {
+      validateNoAdditionalProperties(source, '/source', ['repoVersion', 'repoCommit', 'manifestVersion']);
+      validateOptionalString(source.repoVersion, '/source/repoVersion');
+      validateOptionalString(source.repoCommit, '/source/repoCommit');
+      if (!Number.isInteger(source.manifestVersion) || source.manifestVersion < 1) {
+        pushError('/source/manifestVersion', 'must be integer >= 1');
+      }
+    }
+
+    if (!Array.isArray(state.operations)) {
+      pushError('/operations', 'must be array');
+    } else {
+      for (let index = 0; index < state.operations.length; index += 1) {
+        const operation = state.operations[index];
+        const instancePath = `/operations/${index}`;
+
+        if (!operation || typeof operation !== 'object' || Array.isArray(operation)) {
+          pushError(instancePath, 'must be object');
+          continue;
+        }
+
+        if (!isNonEmptyString(operation.kind)) {
+          pushError(`${instancePath}/kind`, 'must be non-empty string');
+        }
+        if (!isNonEmptyString(operation.moduleId)) {
+          pushError(`${instancePath}/moduleId`, 'must be non-empty string');
+        }
+        if (!isNonEmptyString(operation.sourceRelativePath)) {
+          pushError(`${instancePath}/sourceRelativePath`, 'must be non-empty string');
+        }
+        if (!isNonEmptyString(operation.destinationPath)) {
+          pushError(`${instancePath}/destinationPath`, 'must be non-empty string');
+        }
+        if (!isNonEmptyString(operation.strategy)) {
+          pushError(`${instancePath}/strategy`, 'must be non-empty string');
+        }
+        if (!isNonEmptyString(operation.ownership)) {
+          pushError(`${instancePath}/ownership`, 'must be non-empty string');
+        }
+        if (typeof operation.scaffoldOnly !== 'boolean') {
+          pushError(`${instancePath}/scaffoldOnly`, 'must be boolean');
+        }
+      }
+    }
+
+    return errors.length === 0;
+  };
+
+  validate.errors = [];
+  return validate;
+}
+
+function formatValidationErrors(errors = []) {
+  return errors
+    .map(error => `${error.instancePath || '/'} ${error.message}`)
+    .join('; ');
+}
+
+function validateInstallState(state) {
+  const validator = getValidator();
+  const valid = validator(state);
+  return {
+    valid,
+    errors: validator.errors || [],
+  };
+}
+
+function assertValidInstallState(state, label) {
+  const result = validateInstallState(state);
+  if (!result.valid) {
+    throw new Error(`Invalid install-state${label ? ` (${label})` : ''}: ${formatValidationErrors(result.errors)}`);
+  }
+}
+
+function createInstallState(options) {
+  const installedAt = options.installedAt || new Date().toISOString();
+  const state = {
+    schemaVersion: 'ecc.install.v1',
+    installedAt,
+    target: {
+      id: options.adapter.id,
+      target: options.adapter.target || undefined,
+      kind: options.adapter.kind || undefined,
+      root: options.targetRoot,
+      installStatePath: options.installStatePath,
+    },
+    request: {
+      profile: options.request.profile || null,
+      modules: Array.isArray(options.request.modules) ? [...options.request.modules] : [],
+      includeComponents: Array.isArray(options.request.includeComponents)
+        ? [...options.request.includeComponents]
+        : [],
+      excludeComponents: Array.isArray(options.request.excludeComponents)
+        ? [...options.request.excludeComponents]
+        : [],
+      legacyLanguages: Array.isArray(options.request.legacyLanguages)
+        ? [...options.request.legacyLanguages]
+        : [],
+      legacyMode: Boolean(options.request.legacyMode),
+    },
+    resolution: {
+      selectedModules: Array.isArray(options.resolution.selectedModules)
+        ? [...options.resolution.selectedModules]
+        : [],
+      skippedModules: Array.isArray(options.resolution.skippedModules)
+        ? [...options.resolution.skippedModules]
+        : [],
+    },
+    source: {
+      repoVersion: options.source.repoVersion || null,
+      repoCommit: options.source.repoCommit || null,
+      manifestVersion: options.source.manifestVersion,
+    },
+    operations: Array.isArray(options.operations)
+      ? options.operations.map(operation => cloneJsonValue(operation))
+      : [],
+  };
+
+  if (options.lastValidatedAt) {
+    state.lastValidatedAt = options.lastValidatedAt;
+  }
+
+  assertValidInstallState(state, 'create');
+  return state;
+}
+
+function readInstallState(filePath) {
+  const state = readJson(filePath, 'install-state');
+  assertValidInstallState(state, filePath);
+  return state;
+}
+
+function writeInstallState(filePath, state) {
+  assertValidInstallState(state, filePath);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}\n`);
+  return state;
+}
+
+module.exports = {
+  createInstallState,
+  readInstallState,
+  validateInstallState,
+  writeInstallState,
+};

package/scripts/lib/install-targets/antigravity-project.js

@@ -0,0 +1,69 @@
+const path = require('path');
+
+const {
+  createFlatRuleOperations,
+  createInstallTargetAdapter,
+  createManagedScaffoldOperation,
+} = require('./helpers');
+
+module.exports = createInstallTargetAdapter({
+  id: 'antigravity-project',
+  target: 'antigravity',
+  kind: 'project',
+  rootSegments: ['.agent'],
+  installStatePathSegments: ['ecc-install-state.json'],
+  planOperations(input, adapter) {
+    const modules = Array.isArray(input.modules)
+      ? input.modules
+      : (input.module ? [input.module] : []);
+    const {
+      repoRoot,
+      projectRoot,
+      homeDir,
+    } = input;
+    const planningInput = {
+      repoRoot,
+      projectRoot,
+      homeDir,
+    };
+    const targetRoot = adapter.resolveRoot(planningInput);
+
+    return modules.flatMap(module => {
+      const paths = Array.isArray(module.paths) ? module.paths : [];
+      return paths.flatMap(sourceRelativePath => {
+        if (sourceRelativePath === 'rules') {
+          return createFlatRuleOperations({
+            moduleId: module.id,
+            repoRoot,
+            sourceRelativePath,
+            destinationDir: path.join(targetRoot, 'rules'),
+          });
+        }
+
+        if (sourceRelativePath === 'commands') {
+          return [
+            createManagedScaffoldOperation(
+              module.id,
+              sourceRelativePath,
+              path.join(targetRoot, 'workflows'),
+              'preserve-relative-path'
+            ),
+          ];
+        }
+
+        if (sourceRelativePath === 'agents') {
+          return [
+            createManagedScaffoldOperation(
+              module.id,
+              sourceRelativePath,
+              path.join(targetRoot, 'skills'),
+              'preserve-relative-path'
+            ),
+          ];
+        }
+
+        return [adapter.createScaffoldOperation(module.id, sourceRelativePath, planningInput)];
+      });
+    });
+  },
+});

package/scripts/lib/install-targets/claude-home.js

@@ -0,0 +1,54 @@
+const path = require('path');
+
+const {
+  createInstallTargetAdapter,
+  createRemappedOperation,
+} = require('./helpers');
+const {
+  getClaudeAwHookConfigSourceRelativePath,
+} = require('../claude-aw-hook-files');
+
+module.exports = createInstallTargetAdapter({
+  id: 'claude-home',
+  target: 'claude',
+  kind: 'home',
+  rootSegments: ['.claude'],
+  installStatePathSegments: ['ecc', 'install-state.json'],
+  nativeRootRelativePath: '.claude-plugin',
+  planOperations(input, adapter) {
+    const modules = Array.isArray(input.modules)
+      ? input.modules
+      : (input.module ? [input.module] : []);
+    const {
+      repoRoot,
+      projectRoot,
+      homeDir,
+    } = input;
+    const planningInput = {
+      repoRoot,
+      projectRoot,
+      homeDir,
+    };
+    const targetRoot = adapter.resolveRoot(planningInput);
+
+    return modules.flatMap(module => {
+      const paths = Array.isArray(module.paths) ? module.paths : [];
+      return paths.flatMap(sourceRelativePath => {
+        if (sourceRelativePath === 'hooks') {
+          return [
+            adapter.createScaffoldOperation(module.id, sourceRelativePath, planningInput),
+            createRemappedOperation(
+              adapter,
+              module.id,
+              getClaudeAwHookConfigSourceRelativePath(),
+              path.join(targetRoot, 'hooks', 'hooks.json'),
+              { strategy: 'flatten-copy' }
+            ),
+          ];
+        }
+
+        return [adapter.createScaffoldOperation(module.id, sourceRelativePath, planningInput)];
+      });
+    });
+  },
+});

package/scripts/lib/install-targets/codex-home.js

@@ -0,0 +1,62 @@
+const path = require('path');
+
+const {
+  createInstallTargetAdapter,
+  createRemappedOperation,
+} = require('./helpers');
+const {
+  getCodexAwHookConfigSourceRelativePath,
+  getCodexAwHookSourceRelativeDir,
+} = require('../codex-aw-hook-files');
+
+module.exports = createInstallTargetAdapter({
+  id: 'codex-home',
+  target: 'codex',
+  kind: 'home',
+  rootSegments: ['.codex'],
+  installStatePathSegments: ['ecc-install-state.json'],
+  nativeRootRelativePath: '.codex',
+  planOperations(input, adapter) {
+    const modules = Array.isArray(input.modules)
+      ? input.modules
+      : (input.module ? [input.module] : []);
+    const {
+      repoRoot,
+      projectRoot,
+      homeDir,
+    } = input;
+    const planningInput = {
+      repoRoot,
+      projectRoot,
+      homeDir,
+    };
+    const targetRoot = adapter.resolveRoot(planningInput);
+
+    return modules.flatMap(module => {
+      const paths = Array.isArray(module.paths) ? module.paths : [];
+      return paths.flatMap(sourceRelativePath => {
+        if (sourceRelativePath === '.codex') {
+          return [
+            adapter.createScaffoldOperation(module.id, sourceRelativePath, planningInput),
+            createRemappedOperation(
+              adapter,
+              module.id,
+              getCodexAwHookSourceRelativeDir(),
+              path.join(targetRoot, 'hooks'),
+              { strategy: 'sync-root-children' }
+            ),
+            createRemappedOperation(
+              adapter,
+              module.id,
+              getCodexAwHookConfigSourceRelativePath(),
+              path.join(targetRoot, 'hooks.json'),
+              { strategy: 'flatten-copy' }
+            ),
+          ];
+        }
+
+        return [adapter.createScaffoldOperation(module.id, sourceRelativePath, planningInput)];
+      });
+    });
+  },
+});

package/scripts/lib/install-targets/cursor-project.js

@@ -0,0 +1,80 @@
+const path = require('path');
+
+const {
+  createFlatRuleOperations,
+  createRemappedOperation,
+  createInstallTargetAdapter,
+} = require('./helpers');
+const {
+  getCursorAwHookSourceRelativeDir,
+  getCursorAwHookConfigSourceRelativePath,
+  getCursorAwSharedHookSourceRelativeDir,
+} = require('../cursor-aw-hook-files');
+
+module.exports = createInstallTargetAdapter({
+  id: 'cursor-project',
+  target: 'cursor',
+  kind: 'project',
+  rootSegments: ['.cursor'],
+  installStatePathSegments: ['ecc-install-state.json'],
+  nativeRootRelativePath: '.cursor',
+  planOperations(input, adapter) {
+    const modules = Array.isArray(input.modules)
+      ? input.modules
+      : (input.module ? [input.module] : []);
+    const {
+      repoRoot,
+      projectRoot,
+      homeDir,
+    } = input;
+    const planningInput = {
+      repoRoot,
+      projectRoot,
+      homeDir,
+    };
+    const targetRoot = adapter.resolveRoot(planningInput);
+
+    return modules.flatMap(module => {
+      const paths = Array.isArray(module.paths) ? module.paths : [];
+      return paths.flatMap(sourceRelativePath => {
+        if (sourceRelativePath === 'rules') {
+          return createFlatRuleOperations({
+            moduleId: module.id,
+            repoRoot,
+            sourceRelativePath,
+            destinationDir: path.join(targetRoot, 'rules'),
+          });
+        }
+
+        if (sourceRelativePath === '.cursor') {
+          return [
+            adapter.createScaffoldOperation(module.id, sourceRelativePath, planningInput),
+            createRemappedOperation(
+              adapter,
+              module.id,
+              getCursorAwHookSourceRelativeDir(),
+              path.join(targetRoot, 'hooks'),
+              { strategy: 'sync-root-children' }
+            ),
+            createRemappedOperation(
+              adapter,
+              module.id,
+              getCursorAwSharedHookSourceRelativeDir(),
+              path.join(targetRoot, 'hooks', 'shared'),
+              { strategy: 'sync-root-children' }
+            ),
+            createRemappedOperation(
+              adapter,
+              module.id,
+              getCursorAwHookConfigSourceRelativePath(),
+              path.join(targetRoot, 'hooks.json'),
+              { strategy: 'flatten-copy' }
+            ),
+          ];
+        }
+
+        return [adapter.createScaffoldOperation(module.id, sourceRelativePath, planningInput)];
+      });
+    });
+  },
+});