@indigoai-us/hq-cli 5.77.13 → 5.78.0

package/src/utils/manifest.test.ts

@@ -1,167 +0,0 @@
-/**
- * Regression tests for manifest path resolution.
- *
- * Bug caught during hq-core-split S3 testing (2026-04-21): prior to this
- * fix, `getManifestPath()` returned a flat path (`{hqRoot}/modules.yaml`),
- * but real HQ installs use the nested layout (`{hqRoot}/modules/modules.yaml`).
- * Running `hq install` against a real HQ would silently create a shadow
- * manifest at the root, orphaning the canonical nested one.
- *
- * These tests lock in:
- *   1. Nested layout is preferred when it exists.
- *   2. Flat layout is honored when (and only when) it already exists.
- *   3. Fresh HQs default to writing the nested form — never shadow-writing
- *      a root-level `modules.yaml`.
- *   4. Read/write round-trips correctly against the nested layout.
- */
-
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import * as yaml from 'js-yaml';
-
-import {
-  addModule,
-  getManifestPath,
-  readManifest,
-  writeManifest,
-} from './manifest.js';
-import type { ModulesManifest } from '../types.js';
-import { isExpectedUserError } from './expected-cli-error.js';
-
-let tmpRoot: string;
-
-beforeEach(() => {
-  tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'hq-manifest-test-'));
-});
-
-afterEach(() => {
-  fs.rmSync(tmpRoot, { recursive: true, force: true });
-});
-
-const sampleManifest: ModulesManifest = {
-  version: '1',
-  modules: [
-    {
-      name: 'knowledge-public-hq-core',
-      repo: 'https://github.com/indigoai-us/knowledge-public-hq-core.git',
-      strategy: 'link',
-      paths: [
-        {
-          src: '.',
-          dest: 'knowledge/public/hq-core',
-        },
-      ],
-    },
-  ],
-};
-
-describe('getManifestPath', () => {
-  it('prefers nested modules/modules.yaml when it exists', () => {
-    const nested = path.join(tmpRoot, 'modules', 'modules.yaml');
-    fs.mkdirSync(path.dirname(nested), { recursive: true });
-    fs.writeFileSync(nested, yaml.dump(sampleManifest));
-
-    expect(getManifestPath(tmpRoot)).toBe(nested);
-  });
-
-  it('honors legacy flat modules.yaml when only the flat form exists', () => {
-    // Legacy fixtures / very old HQ instances may pre-date the nested layout.
-    const flat = path.join(tmpRoot, 'modules.yaml');
-    fs.writeFileSync(flat, yaml.dump(sampleManifest));
-
-    expect(getManifestPath(tmpRoot)).toBe(flat);
-  });
-
-  it('defaults to nested path on a fresh HQ (neither file exists)', () => {
-    // Regression: previously returned the flat path, which meant writeManifest
-    // created a shadow root-level manifest on real HQs.
-    expect(getManifestPath(tmpRoot)).toBe(
-      path.join(tmpRoot, 'modules', 'modules.yaml'),
-    );
-  });
-});
-
-describe('readManifest / writeManifest round-trip', () => {
-  it('surfaces malformed user YAML with the manifest file and location', () => {
-    const nested = path.join(tmpRoot, 'modules', 'modules.yaml');
-    fs.mkdirSync(path.dirname(nested), { recursive: true });
-    fs.writeFileSync(nested, 'modules:\n  - name: hq\n bad: indentation\n');
-
-    const error = (() => {
-      try {
-        readManifest(tmpRoot);
-      } catch (err) {
-        return err;
-      }
-      throw new Error('expected malformed YAML to throw');
-    })();
-
-    expect(isExpectedUserError(error)).toBe(true);
-    expect((error as Error).message).toContain(`${nested}:3:2`);
-  });
-
-  it('round-trips against the nested layout', () => {
-    writeManifest(tmpRoot, sampleManifest);
-
-    const nested = path.join(tmpRoot, 'modules', 'modules.yaml');
-    expect(fs.existsSync(nested)).toBe(true);
-
-    const roundTripped = readManifest(tmpRoot);
-    expect(roundTripped).toEqual(sampleManifest);
-  });
-
-  it('writes into the nested modules/ dir on fresh HQs (creates dir)', () => {
-    // The nested dir does not exist yet — writeManifest must mkdir-p.
-    expect(fs.existsSync(path.join(tmpRoot, 'modules'))).toBe(false);
-
-    writeManifest(tmpRoot, sampleManifest);
-
-    expect(fs.existsSync(path.join(tmpRoot, 'modules'))).toBe(true);
-    expect(fs.existsSync(path.join(tmpRoot, 'modules', 'modules.yaml'))).toBe(
-      true,
-    );
-  });
-
-  it('does NOT shadow-write a root-level modules.yaml on fresh HQs', () => {
-    // This is the original bug: pre-fix, writeManifest on a fresh HQ created
-    // `{hqRoot}/modules.yaml`, which shadowed the canonical nested manifest.
-    writeManifest(tmpRoot, sampleManifest);
-
-    expect(fs.existsSync(path.join(tmpRoot, 'modules.yaml'))).toBe(false);
-  });
-
-  it('rewrites into the flat layout when flat already exists (legacy compat)', () => {
-    const flat = path.join(tmpRoot, 'modules.yaml');
-    fs.writeFileSync(flat, yaml.dump({ version: '1', modules: [] }));
-
-    writeManifest(tmpRoot, sampleManifest);
-
-    // Flat stays flat; no silent migration to nested, no shadow write.
-    expect(fs.existsSync(flat)).toBe(true);
-    expect(
-      fs.existsSync(path.join(tmpRoot, 'modules', 'modules.yaml')),
-    ).toBe(false);
-
-    const reread = readManifest(tmpRoot);
-    expect(reread).toEqual(sampleManifest);
-  });
-});
-
-describe('addModule', () => {
-  it('appends to the existing nested manifest without creating a flat shadow', () => {
-    writeManifest(tmpRoot, sampleManifest);
-
-    addModule(tmpRoot, {
-      name: 'knowledge-public-testing',
-      repo: 'https://github.com/indigoai-us/knowledge-public-testing.git',
-      strategy: 'link',
-      paths: [{ src: '.', dest: 'knowledge/public/testing' }],
-    });
-
-    const after = readManifest(tmpRoot);
-    expect(after?.modules).toHaveLength(2);
-    expect(fs.existsSync(path.join(tmpRoot, 'modules.yaml'))).toBe(false);
-  });
-});

package/src/utils/manifest.ts

@@ -1,131 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-import type { ModulesManifest, ModuleDefinition, ModuleLock, SyncState } from '../types.js';
-import { parseUserYaml } from './user-yaml-error.js';
-
-const MANIFEST_FILE = 'modules.yaml';
-const LOCK_FILE = 'modules.lock';
-const STATE_FILE = '.hq-sync-state.json';
-
-export function findHqRoot(): string {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (fs.existsSync(path.join(dir, '.claude')) || fs.existsSync(path.join(dir, 'workers'))) {
-      return dir;
-    }
-    dir = path.dirname(dir);
-  }
-  return process.cwd();
-}
-
-/**
- * Resolve the manifest path for a given HQ root.
- *
- * The canonical layout is nested: `{hqRoot}/modules/modules.yaml` (catalog)
- * alongside `{hqRoot}/modules/<module-name>/` (clone targets).
- *
- * Legacy fixtures and very old HQ instances may have the flat layout
- * (`{hqRoot}/modules.yaml`); we honor that if — and only if — the flat file
- * already exists. On fresh HQs we default to the nested form so we never
- * silently create a second shadow manifest at the root.
- *
- * Exported for tests.
- */
-export function getManifestPath(hqRoot: string): string {
-  const nested = path.join(hqRoot, 'modules', MANIFEST_FILE);
-  const flat = path.join(hqRoot, MANIFEST_FILE);
-  if (fs.existsSync(nested)) return nested;
-  if (fs.existsSync(flat)) return flat;
-  return nested; // default for fresh HQs — see getModulesDir()
-}
-
-export function getLockPath(hqRoot: string): string {
-  return path.join(hqRoot, LOCK_FILE);
-}
-
-export function getStatePath(hqRoot: string): string {
-  return path.join(hqRoot, STATE_FILE);
-}
-
-export function getModulesDir(hqRoot: string): string {
-  return path.join(hqRoot, 'modules');
-}
-
-export function readManifest(hqRoot: string): ModulesManifest | null {
-  const manifestPath = getManifestPath(hqRoot);
-  if (!fs.existsSync(manifestPath)) {
-    return null;
-  }
-  const content = fs.readFileSync(manifestPath, 'utf-8');
-  return parseUserYaml<ModulesManifest>(content, manifestPath);
-}
-
-export function writeManifest(hqRoot: string, manifest: ModulesManifest): void {
-  const manifestPath = getManifestPath(hqRoot);
-  // Ensure the parent directory exists — on a fresh HQ the nested
-  // `modules/` dir may not yet be present, and fs.writeFileSync does not
-  // auto-mkdir. Safe no-op when the dir already exists.
-  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
-  const content = yaml.dump(manifest, { lineWidth: -1 });
-  fs.writeFileSync(manifestPath, content);
-}
-
-export function readLock(hqRoot: string): ModuleLock | null {
-  const lockPath = getLockPath(hqRoot);
-  if (!fs.existsSync(lockPath)) {
-    return null;
-  }
-  const content = fs.readFileSync(lockPath, 'utf-8');
-  return parseUserYaml<ModuleLock>(content, lockPath);
-}
-
-export function writeLock(hqRoot: string, lock: ModuleLock): void {
-  const lockPath = getLockPath(hqRoot);
-  const content = yaml.dump(lock, { lineWidth: -1 });
-  fs.writeFileSync(lockPath, content);
-}
-
-export function readState(hqRoot: string): SyncState | null {
-  const statePath = getStatePath(hqRoot);
-  if (!fs.existsSync(statePath)) {
-    return null;
-  }
-  const content = fs.readFileSync(statePath, 'utf-8');
-  return JSON.parse(content) as SyncState;
-}
-
-export function writeState(hqRoot: string, state: SyncState): void {
-  const statePath = getStatePath(hqRoot);
-  fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
-}
-
-export function addModule(hqRoot: string, module: ModuleDefinition): void {
-  let manifest = readManifest(hqRoot);
-  if (!manifest) {
-    manifest = { version: '1', modules: [] };
-  }
-
-  // Check for duplicates
-  if (manifest.modules.some(m => m.name === module.name)) {
-    throw new Error(`Module "${module.name}" already exists`);
-  }
-
-  manifest.modules.push(module);
-  writeManifest(hqRoot, manifest);
-}
-
-export function parseRepoName(repoUrl: string): string {
-  // Extract repo name from URL
-  // https://github.com/user/repo.git -> repo
-  // git@github.com:user/repo.git -> repo
-  const match = repoUrl.match(/[\/:]([^\/]+?)(\.git)?$/);
-  if (!match) {
-    throw new Error(`Cannot parse repo name from: ${repoUrl}`);
-  }
-  return match[1];
-}
-
-export function isValidRepoUrl(url: string): boolean {
-  return url.startsWith('https://') || url.startsWith('git@');
-}