@slats/claude-assets-sync 0.2.0 → 0.3.1

package/scripts/dev-ui.tsx

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+import { render, Box, Text, useApp, useInput } from 'ink';
+import React, { useEffect, useState } from 'react';
+
+import { Banner } from '../src/ui/components/Banner.js';
+import { ConfirmForce } from '../src/ui/components/ConfirmForce.js';
+import { ErrorPanel } from '../src/ui/components/ErrorPanel.js';
+import { Footer } from '../src/ui/components/Footer.js';
+import { ProgressBar } from '../src/ui/components/ProgressBar.js';
+import { ScopePicker } from '../src/ui/components/ScopePicker.js';
+import { Spinner } from '../src/ui/components/Spinner.js';
+import { StepTracker } from '../src/ui/components/StepTracker.js';
+import { Summary } from '../src/ui/components/Summary.js';
+import { TargetCard } from '../src/ui/components/TargetCard.js';
+import { colors } from '../src/ui/theme/colors.js';
+import { icons } from '../src/ui/theme/icons.js';
+import type { Phase } from '../src/ui/types/index.js';
+
+import { buildPhase, PHASES, type PhaseKey } from './dev-ui-fixtures.js';
+
+const VERSION = '0.3.0-dev';
+
+interface CliArgs {
+  mode: 'usage' | 'phase' | 'tour';
+  phase?: PhaseKey;
+  tourMs?: number;
+}
+
+function parseArgs(argv: readonly string[]): CliArgs {
+  if (argv.includes('--tour')) {
+    const msArg = argv.find((a) => a.startsWith('--ms='));
+    const tourMs = msArg ? Number(msArg.slice(5)) : 2500;
+    return { mode: 'tour', tourMs };
+  }
+  const phaseArg = argv.find((a) => a.startsWith('--phase='));
+  if (phaseArg) {
+    const phaseKey = phaseArg.slice(8);
+    if (!PHASES.includes(phaseKey as PhaseKey)) {
+      console.error(
+        `Unknown phase: ${phaseKey}. Available: ${PHASES.join(', ')}`,
+      );
+      process.exit(2);
+    }
+    return { mode: 'phase', phase: phaseKey as PhaseKey };
+  }
+  return { mode: 'usage' };
+}
+
+function Usage(): React.ReactElement {
+  return (
+    <Box flexDirection="column">
+      <Text bold color={colors.primary}>
+        {icons.triangleRight} claude-assets-sync — dev UI runner
+      </Text>
+      <Box marginLeft={2} marginTop={1} flexDirection="column">
+        <Text color={colors.muted}>Preview individual Ink screens or tour them all.</Text>
+        <Box marginTop={1} flexDirection="column">
+          <Text>
+            <Text color={colors.success} bold>yarn dev:ui</Text>
+            <Text color={colors.muted}>{' --phase=<name>      '}</Text>
+            <Text dimColor>single phase preview</Text>
+          </Text>
+          <Text>
+            <Text color={colors.success} bold>yarn dev:ui</Text>
+            <Text color={colors.muted}>{' --tour [--ms=2500]  '}</Text>
+            <Text dimColor>cycle through all phases</Text>
+          </Text>
+          <Text>
+            <Text color={colors.success} bold>yarn dev:cli</Text>
+            <Text color={colors.muted}>{' <args>             '}</Text>
+            <Text dimColor>run the actual CLI against real packages</Text>
+          </Text>
+        </Box>
+        <Box marginTop={1} flexDirection="column">
+          <Text bold>Available phases:</Text>
+          {PHASES.map((p) => (
+            <Text key={p} color={colors.muted}>
+              {'  '}·{' '}
+              <Text color={colors.accent}>{p}</Text>
+            </Text>
+          ))}
+        </Box>
+        <Box marginTop={1} flexDirection="column">
+          <Text bold>Examples:</Text>
+          <Text color={colors.muted}>
+            {'  '}yarn dev:ui --phase=diff-review
+          </Text>
+          <Text color={colors.muted}>
+            {'  '}yarn dev:ui --phase=applying
+          </Text>
+          <Text color={colors.muted}>
+            {'  '}yarn dev:ui --tour --ms=1800
+          </Text>
+          <Text color={colors.muted}>
+            {'  '}yarn dev:cli --package @canard/schema-form --scope=project --dry-run
+          </Text>
+        </Box>
+      </Box>
+    </Box>
+  );
+}
+
+interface FixtureViewProps {
+  readonly phase: Phase;
+  readonly targetCount: number;
+}
+
+function FixtureView({ phase, targetCount }: FixtureViewProps): React.ReactElement {
+  return (
+    <Box flexDirection="column">
+      <Banner version={VERSION} scope="user" />
+      <Box marginTop={1}>
+        <StepTracker phase={phase} targetCount={targetCount} scope="user" />
+      </Box>
+      <Box flexDirection="column" marginTop={1}>
+        {renderPhaseBody(phase)}
+      </Box>
+      <Footer phase={phase} version={VERSION} />
+    </Box>
+  );
+}
+
+function renderPhaseBody(phase: Phase): React.ReactNode {
+  switch (phase.kind) {
+    case 'booting':
+    case 'resolving':
+      return <Spinner label="resolving targets…" />;
+    case 'scope-select':
+      return <ScopePicker onSelect={phase.pending} />;
+    case 'planning':
+      return (
+        <Box flexDirection="column">
+          <Spinner label="building plans…" />
+          <Box flexDirection="column" marginLeft={2} marginTop={1}>
+            {[...phase.progress.values()].map((step) => (
+              <Box key={step.packageName}>
+                <Text
+                  color={
+                    step.status === 'done'
+                      ? colors.success
+                      : step.status === 'running'
+                        ? colors.warn
+                        : step.status === 'failed'
+                          ? colors.danger
+                          : colors.muted
+                  }
+                  bold={step.status === 'running'}
+                >
+                  {step.status === 'done'
+                    ? icons.check
+                    : step.status === 'failed'
+                      ? icons.cross
+                      : step.status === 'running'
+                        ? icons.bulletActive
+                        : icons.bulletPending}{' '}
+                </Text>
+                <Text>{step.packageName}</Text>
+              </Box>
+            ))}
+          </Box>
+        </Box>
+      );
+    case 'diff-review':
+      return (
+        <Box flexDirection="column">
+          {phase.plans.map((tp, idx) => (
+            <TargetCard
+              key={tp.target.name}
+              target={tp.target}
+              plan={tp.plan}
+              expanded
+              highlighted={idx === phase.focusedIndex}
+            />
+          ))}
+        </Box>
+      );
+    case 'force-confirm':
+      return <ConfirmForce warnings={phase.warnings} onAnswer={phase.pending} />;
+    case 'applying': {
+      const elapsedMs = Math.max(Date.now() - phase.progress.startedAt, 1);
+      const rate = phase.progress.done / elapsedMs;
+      const remaining = phase.progress.total - phase.progress.done;
+      const eta = rate > 0 ? remaining / rate / 1000 : undefined;
+      return (
+        <Box flexDirection="column">
+          <ProgressBar
+            done={phase.progress.done}
+            total={phase.progress.total}
+            etaSeconds={eta}
+            label={phase.progress.current}
+          />
+          <Box flexDirection="column" marginLeft={2} marginTop={1}>
+            {phase.plans.map((tp) => (
+              <TargetCard
+                key={tp.target.name}
+                target={tp.target}
+                plan={tp.plan}
+                expanded={false}
+              />
+            ))}
+          </Box>
+        </Box>
+      );
+    }
+    case 'summary':
+      return (
+        <Box flexDirection="column">
+          {phase.plans.map((tp) => (
+            <TargetCard
+              key={tp.target.name}
+              target={tp.target}
+              plan={tp.plan}
+              expanded={false}
+            />
+          ))}
+          <Summary
+            reports={phase.reports}
+            exitCode={phase.exitCode}
+            dryRun={phase.dryRun}
+          />
+        </Box>
+      );
+    case 'error':
+      return <ErrorPanel error={phase.error} />;
+    default: {
+      const _exhaustive: never = phase;
+      void _exhaustive;
+      return null;
+    }
+  }
+}
+
+function PhaseApp({ phaseKey }: { phaseKey: PhaseKey }): React.ReactElement {
+  const { exit } = useApp();
+  const phase = buildPhase(phaseKey);
+  useInput((input) => {
+    if (input === 'q' || input === '') exit();
+  });
+  return <FixtureView phase={phase} targetCount={3} />;
+}
+
+function TourApp({ intervalMs }: { intervalMs: number }): React.ReactElement {
+  const { exit } = useApp();
+  const [idx, setIdx] = useState(0);
+  useEffect(() => {
+    const handle = setInterval(() => {
+      setIdx((current) => {
+        if (current + 1 >= PHASES.length) {
+          setTimeout(() => exit(), 300);
+          return current;
+        }
+        return current + 1;
+      });
+    }, intervalMs);
+    return () => clearInterval(handle);
+  }, [intervalMs, exit]);
+  useInput((input) => {
+    if (input === 'q' || input === '') exit();
+    if (input === ' ')
+      setIdx((current) =>
+        current + 1 >= PHASES.length ? current : current + 1,
+      );
+  });
+  const phaseKey = PHASES[idx];
+  const phase = buildPhase(phaseKey);
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Text color={colors.accent} bold>
+          [tour {idx + 1}/{PHASES.length}]
+        </Text>
+        <Text color={colors.muted} dimColor>
+          {'  '}
+          {phaseKey}  ·  space:next  ·  q/esc:exit
+        </Text>
+      </Box>
+      <FixtureView phase={phase} targetCount={3} />
+    </Box>
+  );
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (args.mode === 'usage') {
+  render(<Usage />);
+} else if (args.mode === 'phase') {
+  render(<PhaseApp phaseKey={args.phase!} />);
+} else if (args.mode === 'tour') {
+  render(<TourApp intervalMs={args.tourMs ?? 2500} />);
+}

package/bin/claude-sync.mjs

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-import { runCli } from '@slats/claude-assets-sync';
-import { readFile } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const pkg = JSON.parse(
-  await readFile(resolve(packageRoot, 'package.json'), 'utf-8'),
-);
-
-if (typeof pkg.claude?.assetPath === 'string') {
-  runCli(process.argv, {
-    packageRoot,
-    packageName: pkg.name,
-    packageVersion: pkg.version,
-    assetPath: pkg.claude.assetPath,
-  }).catch((err) => {
-    process.stderr.write(
-      `[${pkg.name}] claude-sync failed: ${err instanceof Error ? err.message : String(err)}\n`,
-    );
-    process.exit(1);
-  });
-}

package/dist/commands/runCli/runCli.cjs

@@ -1,31 +0,0 @@
-'use strict';
-
-var commander = require('commander');
-var logger = require('../../utils/logger.cjs');
-var version = require('../../utils/version.cjs');
-var runInject = require('./utils/runInject.cjs');
-
-async function runCli(argv = process.argv, options) {
-    const cmd = new commander.Command();
-    cmd
-        .name('claude-sync')
-        .description("Inject this package's assets into the target .claude directory")
-        .version(options.version ?? version.VERSION)
-        .option('--scope <scope>', 'Target scope: user (~/.claude) | project (nearest ancestor .claude or <cwd>/.claude)')
-        .option('--dry-run', 'Preview without writing', false)
-        .option('--force', 'Overwrite user modifications', false)
-        .option('--root <path>', 'Override scope resolution cwd (default: cwd)')
-        .action(async (flags) => {
-        await runInject.runInject(flags, options);
-    });
-    try {
-        await cmd.parseAsync([...argv]);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        logger.logger.error(msg);
-        process.exit(1);
-    }
-}
-
-exports.runCli = runCli;

package/dist/commands/runCli/utils/injectOne.cjs

@@ -1,48 +0,0 @@
-'use strict';
-
-require('node:crypto');
-require('node:fs/promises');
-require('node:path');
-var injectDocs = require('../../../core/injectDocs/injectDocs.cjs');
-require('node:os');
-require('node:fs');
-require('@inquirer/prompts');
-require('picocolors');
-var confirmForce = require('../../../prompts/confirmForce.cjs');
-var heartbeat = require('../../../utils/heartbeat.cjs');
-var logger = require('../../../utils/logger.cjs');
-
-async function injectOne(target, scope, flags, originCwd) {
-    if (!target.hashesPresent) {
-        logger.logger.warn(`${target.name}: dist/claude-hashes.json missing — build the package (e.g. yarn build) to regenerate the hash manifest first.`);
-        return;
-    }
-    logger.logger.heading(`${target.name}@${target.version}`);
-    const stopHeartbeat = heartbeat.startHeartbeat({
-        label: `injecting ${target.name}`,
-    });
-    try {
-        const report = await injectDocs.injectDocs({
-            packageName: target.name,
-            packageVersion: target.version,
-            packageRoot: target.packageRoot,
-            assetRoot: target.assetRoot,
-            scope,
-            originCwd,
-            dryRun: flags.dryRun ?? false,
-            force: flags.force ?? false,
-            confirmForce: async (plan) => {
-                const diverged = plan.actions.filter((a) => a.kind === 'warn-diverged');
-                const orphans = plan.actions.filter((a) => a.kind === 'warn-orphan');
-                return confirmForce.confirmForceAsync(diverged.length, orphans.length, [...diverged, ...orphans].map((a) => a.relPath).slice(0, 3));
-            },
-        });
-        if (report.exitCode !== 0)
-            process.exit(report.exitCode);
-    }
-    finally {
-        stopHeartbeat();
-    }
-}
-
-exports.injectOne = injectOne;

package/dist/commands/runCli/utils/injectOne.d.ts

@@ -1,3 +0,0 @@
-import { type Scope } from '../../../core/index.js';
-import type { ConsumerPackage, DefaultFlags } from '../type.js';
-export declare function injectOne(target: ConsumerPackage, scope: Scope, flags: DefaultFlags, originCwd: string): Promise<void>;

package/dist/commands/runCli/utils/injectOne.mjs

@@ -1,46 +0,0 @@
-import 'node:crypto';
-import 'node:fs/promises';
-import 'node:path';
-import { injectDocs } from '../../../core/injectDocs/injectDocs.mjs';
-import 'node:os';
-import 'node:fs';
-import '@inquirer/prompts';
-import 'picocolors';
-import { confirmForceAsync } from '../../../prompts/confirmForce.mjs';
-import { startHeartbeat } from '../../../utils/heartbeat.mjs';
-import { logger } from '../../../utils/logger.mjs';
-
-async function injectOne(target, scope, flags, originCwd) {
-    if (!target.hashesPresent) {
-        logger.warn(`${target.name}: dist/claude-hashes.json missing — build the package (e.g. yarn build) to regenerate the hash manifest first.`);
-        return;
-    }
-    logger.heading(`${target.name}@${target.version}`);
-    const stopHeartbeat = startHeartbeat({
-        label: `injecting ${target.name}`,
-    });
-    try {
-        const report = await injectDocs({
-            packageName: target.name,
-            packageVersion: target.version,
-            packageRoot: target.packageRoot,
-            assetRoot: target.assetRoot,
-            scope,
-            originCwd,
-            dryRun: flags.dryRun ?? false,
-            force: flags.force ?? false,
-            confirmForce: async (plan) => {
-                const diverged = plan.actions.filter((a) => a.kind === 'warn-diverged');
-                const orphans = plan.actions.filter((a) => a.kind === 'warn-orphan');
-                return confirmForceAsync(diverged.length, orphans.length, [...diverged, ...orphans].map((a) => a.relPath).slice(0, 3));
-            },
-        });
-        if (report.exitCode !== 0)
-            process.exit(report.exitCode);
-    }
-    finally {
-        stopHeartbeat();
-    }
-}
-
-export { injectOne };

package/dist/commands/runCli/utils/resolveScopeFlag.cjs

@@ -1,28 +0,0 @@
-'use strict';
-
-require('node:crypto');
-require('node:fs/promises');
-require('node:path');
-var logger = require('../../../utils/logger.cjs');
-var scope = require('../../../core/scope/scope.cjs');
-var selectScope = require('../../../prompts/selectScope.cjs');
-require('@inquirer/prompts');
-require('picocolors');
-
-async function resolveScopeFlag(flag) {
-    if (flag) {
-        if (!scope.isValidScope(flag)) {
-            logger.logger.error(`Invalid --scope: ${flag}. Expected user | project.`);
-            process.exit(2);
-        }
-        return flag;
-    }
-    if (!scope.isInteractive()) {
-        logger.logger.error('--scope is required in non-interactive environments.');
-        logger.logger.error('  Pass --scope=user | --scope=project.');
-        process.exit(2);
-    }
-    return selectScope.selectScopeAsync();
-}
-
-exports.resolveScopeFlag = resolveScopeFlag;

package/dist/commands/runCli/utils/runInject.cjs

@@ -1,36 +0,0 @@
-'use strict';
-
-var promises = require('node:fs/promises');
-var node_path = require('node:path');
-var logger = require('../../../utils/logger.cjs');
-var injectOne = require('./injectOne.cjs');
-var resolveScopeFlag = require('./resolveScopeFlag.cjs');
-
-async function runInject(flags, options) {
-    if (!options.packageRoot ||
-        !options.packageName ||
-        !options.packageVersion ||
-        !options.assetPath) {
-        logger.logger.error('runCli requires { packageRoot, packageName, packageVersion, assetPath }.');
-        process.exit(2);
-    }
-    if (!node_path.isAbsolute(options.packageRoot)) {
-        logger.logger.error(`packageRoot must be an absolute path; received: ${options.packageRoot}`);
-        process.exit(2);
-    }
-    const assetRoot = node_path.resolve(options.packageRoot, options.assetPath);
-    const hashesPath = node_path.join(options.packageRoot, 'dist', 'claude-hashes.json');
-    const hashesPresent = await promises.stat(hashesPath).then(() => true, () => false);
-    const target = {
-        name: options.packageName,
-        version: options.packageVersion,
-        packageRoot: options.packageRoot,
-        assetRoot,
-        hashesPresent,
-    };
-    const originCwd = flags.root ?? process.cwd();
-    const scope = await resolveScopeFlag.resolveScopeFlag(flags.scope);
-    await injectOne.injectOne(target, scope, flags, originCwd);
-}
-
-exports.runInject = runInject;

package/dist/commands/runCli/utils/runInject.d.ts

@@ -1,2 +0,0 @@
-import type { DefaultFlags, RunCliOptions } from '../type.js';
-export declare function runInject(flags: DefaultFlags, options: RunCliOptions): Promise<void>;

package/dist/commands/runCli/utils/runInject.mjs

@@ -1,34 +0,0 @@
-import { stat } from 'node:fs/promises';
-import { isAbsolute, resolve, join } from 'node:path';
-import { logger } from '../../../utils/logger.mjs';
-import { injectOne } from './injectOne.mjs';
-import { resolveScopeFlag } from './resolveScopeFlag.mjs';
-
-async function runInject(flags, options) {
-    if (!options.packageRoot ||
-        !options.packageName ||
-        !options.packageVersion ||
-        !options.assetPath) {
-        logger.error('runCli requires { packageRoot, packageName, packageVersion, assetPath }.');
-        process.exit(2);
-    }
-    if (!isAbsolute(options.packageRoot)) {
-        logger.error(`packageRoot must be an absolute path; received: ${options.packageRoot}`);
-        process.exit(2);
-    }
-    const assetRoot = resolve(options.packageRoot, options.assetPath);
-    const hashesPath = join(options.packageRoot, 'dist', 'claude-hashes.json');
-    const hashesPresent = await stat(hashesPath).then(() => true, () => false);
-    const target = {
-        name: options.packageName,
-        version: options.packageVersion,
-        packageRoot: options.packageRoot,
-        assetRoot,
-        hashesPresent,
-    };
-    const originCwd = flags.root ?? process.cwd();
-    const scope = await resolveScopeFlag(flags.scope);
-    await injectOne(target, scope, flags, originCwd);
-}
-
-export { runInject };

package/dist/core/buildPlan/buildPlan.cjs

@@ -1,42 +0,0 @@
-'use strict';
-
-var node_path = require('node:path');
-var hash = require('../hash/hash.cjs');
-var toPosix = require('./utils/toPosix.cjs');
-var walkFiles = require('./utils/walkFiles.cjs');
-
-async function buildPlan(input) {
-    const { sourceHashes, targetRoot, namespacePrefixes, force } = input;
-    const actions = [];
-    let requiresForce = false;
-    for (const [relPath, srcHash] of Object.entries(sourceHashes)) {
-        const dstAbs = node_path.join(targetRoot, relPath);
-        const dstHash = await hash.hashFile(dstAbs);
-        if (dstHash === null)
-            actions.push({ kind: 'copy', relPath, dstAbs });
-        else if (hash.hashEquals(dstHash, srcHash))
-            actions.push({ kind: 'skip-uptodate', relPath, dstAbs });
-        else {
-            actions.push({ kind: 'warn-diverged', relPath, dstAbs });
-            requiresForce = true;
-        }
-    }
-    const known = new Set(Object.keys(sourceHashes));
-    for (const prefix of namespacePrefixes) {
-        const prefixRoot = node_path.join(targetRoot, prefix);
-        for await (const abs of walkFiles.walkFiles(prefixRoot)) {
-            const relPath = toPosix.toPosix(node_path.relative(targetRoot, abs));
-            if (known.has(relPath))
-                continue;
-            if (force)
-                actions.push({ kind: 'delete', relPath, dstAbs: abs });
-            else {
-                actions.push({ kind: 'warn-orphan', relPath, dstAbs: abs });
-                requiresForce = true;
-            }
-        }
-    }
-    return { actions, requiresForce };
-}
-
-exports.buildPlan = buildPlan;

package/dist/core/buildPlan/utils/toPosix.cjs

@@ -1,9 +0,0 @@
-'use strict';
-
-var node_path = require('node:path');
-
-function toPosix(p) {
-    return node_path.sep === '/' ? p : p.split(node_path.sep).join('/');
-}
-
-exports.toPosix = toPosix;

package/dist/core/buildPlan/utils/walkFiles.cjs

@@ -1,25 +0,0 @@
-'use strict';
-
-var promises = require('node:fs/promises');
-var node_path = require('node:path');
-
-async function* walkFiles(root) {
-    let entries;
-    try {
-        entries = await promises.readdir(root, { withFileTypes: true });
-    }
-    catch (err) {
-        if (err.code === 'ENOENT')
-            return;
-        throw err;
-    }
-    for (const entry of entries) {
-        const abs = node_path.join(root, entry.name);
-        if (entry.isDirectory())
-            yield* walkFiles(abs);
-        else if (entry.isFile())
-            yield abs;
-    }
-}
-
-exports.walkFiles = walkFiles;

package/dist/core/hash/hash.cjs

@@ -1,30 +0,0 @@
-'use strict';
-
-var node_crypto = require('node:crypto');
-var promises = require('node:fs/promises');
-
-function hashContent(buffer) {
-    return node_crypto.createHash('sha256').update(buffer).digest('hex');
-}
-async function hashFile(absPath) {
-    try {
-        const buf = await promises.readFile(absPath);
-        return hashContent(buf);
-    }
-    catch (err) {
-        if (err.code === 'ENOENT')
-            return null;
-        throw err;
-    }
-}
-function hashEquals(a, b) {
-    if (a === null || b === null)
-        return false;
-    if (a.length !== b.length)
-        return false;
-    return a.toLowerCase() === b.toLowerCase();
-}
-
-exports.hashContent = hashContent;
-exports.hashEquals = hashEquals;
-exports.hashFile = hashFile;