@ngockhoale/ukit 1.1.6

package/src/cli/commands/doctor.js

@@ -0,0 +1,125 @@
+import path from 'node:path';
+import { pathExists, readJsonIfExists } from '../../core/fileOps.js';
+import { buildPathConfig } from '../../core/paths.js';
+import { buildRuntimePaths } from '../../core/runtimePaths.js';
+import { inspectRuntimeConfig } from '../../core/runtimeConfig.js';
+import { loadManifest } from '../../manifest/loadManifest.js';
+import { detectStack } from '../../stack/detectStack.js';
+import { detectProviders } from '../../context/detectProviders.js';
+
+export const DOCTOR_HELP_FLAGS = new Set(['--help', '-h']);
+const KNOWN_FLAGS = new Set([...DOCTOR_HELP_FLAGS]);
+
+export function printDoctorHelp() {
+  console.log('Usage: ukit doctor [options]');
+  console.log('');
+  console.log('Validate manifest, stack, docs, and UKit state.');
+  console.log('');
+  console.log('Options:');
+  console.log('  --help, -h      Show this help message');
+}
+
+export async function runDoctor({ packageRoot, projectRoot, argv = [] }) {
+  const unknownFlags = argv.filter((flag) => !KNOWN_FLAGS.has(flag));
+  if (unknownFlags.length > 0) {
+    throw new Error(`Unknown option: ${unknownFlags[0]}. Supported: --help, -h`);
+  }
+
+  if (argv.some((flag) => DOCTOR_HELP_FLAGS.has(flag))) {
+    printDoctorHelp();
+    return;
+  }
+
+  const pathConfig = buildPathConfig({ packageRoot, projectRoot });
+  const runtimePaths = buildRuntimePaths(projectRoot);
+  const manifest = await loadManifest(pathConfig.manifestPath);
+  const stack = await detectStack(projectRoot);
+  const providers = await detectProviders(projectRoot);
+  const installMeta = await readJsonIfExists(pathConfig.installMetaPath);
+  const runtimeConfigInspection = await inspectRuntimeConfig(projectRoot);
+
+  const trackedPaths = Array.isArray(installMeta?.files)
+    ? installMeta.files
+      .map((entry) => (typeof entry === 'string' ? entry : entry?.p))
+      .filter((entry) => typeof entry === 'string')
+    : [];
+  const codexAdapterTracked = trackedPaths.some((entry) => entry.startsWith('.codex/'));
+
+  const checks = {
+    manifestLoaded: Boolean(manifest?.name),
+    templatesDirExists: await pathExists(pathConfig.templatesRoot),
+    ukitStateDirExists: await pathExists(pathConfig.ukitRoot),
+    runtimeDirExists: await pathExists(runtimePaths.runtimeRoot),
+    runtimeReadmeExists: await pathExists(path.join(projectRoot, '.ukit', 'README.md')),
+    runtimeConfigExists: runtimeConfigInspection.exists,
+    runtimeConfigValid: runtimeConfigInspection.valid,
+    promptCacheExists: await pathExists(runtimePaths.promptCachePath),
+    compactHistoryExists: await pathExists(runtimePaths.compactHistoryPath),
+    compactPressureExists: await pathExists(runtimePaths.compactPressurePath),
+    outputHistoryExists: await pathExists(runtimePaths.outputHistoryPath),
+    userMemoryExists: await pathExists(runtimePaths.userMemoryPath),
+    projectMemoryDirExists: await pathExists(runtimePaths.projectsDir),
+    sessionMemoryDirExists: await pathExists(runtimePaths.sessionsDir),
+    docsProjectExists: await pathExists(path.join(projectRoot, 'docs', 'PROJECT.md')),
+    docsMemoryExists: await pathExists(path.join(projectRoot, 'docs', 'MEMORY.md')),
+    docsWorklogExists: await pathExists(path.join(projectRoot, 'docs', 'WORKLOG.md')),
+    allProvidersConfigured: providers.allSupported,
+    ...(codexAdapterTracked
+      ? {
+          codexReadmeExists: await pathExists(path.join(projectRoot, '.codex', 'README.md')),
+          codexSettingsExists: await pathExists(path.join(projectRoot, '.codex', 'settings.json')),
+          codexSettingsLocalExists: await pathExists(
+            path.join(projectRoot, '.codex', 'settings.local.json'),
+          ),
+        }
+      : {}),
+  };
+
+  const ok = (v) => (v ? '✓' : '✗');
+
+  const providerNames = Object.keys(providers.providers);
+  const providerStatus = providerNames
+    .map((name) => `${name}=${ok(providers.providers[name].supported)}`)
+    .join(', ');
+
+  console.log('[UKit] Doctor report');
+  console.log(`[UKit] Manifest: ${manifest.name} (v${manifest.version})`);
+  console.log(`[UKit] Stack: frontend=${ok(stack.flags.frontend)}, backendApi=${ok(stack.flags.backendApi)}, postgres=${ok(stack.flags.postgres)}, typescript=${ok(stack.flags.typescript)}`);
+  console.log(`[UKit] Providers: ${providerStatus}, all=${ok(providers.allSupported)}`);
+  console.log('[UKit] Checks:');
+  console.log(`[UKit]   ${ok(checks.manifestLoaded)}  Manifest loaded`);
+  console.log(`[UKit]   ${ok(checks.templatesDirExists)}  Templates directory`);
+  console.log(`[UKit]   ${ok(checks.ukitStateDirExists)}  UKit state directory`);
+  console.log(`[UKit]   ${ok(checks.runtimeDirExists)}  .ukit/`);
+  console.log(`[UKit]   ${ok(checks.runtimeReadmeExists)}  .ukit/README.md`);
+  console.log(`[UKit]   ${ok(checks.runtimeConfigExists)}  .ukit/storage/config.json`);
+  console.log(`[UKit]   ${ok(checks.runtimeConfigValid)}  Runtime config valid`);
+  console.log(`[UKit]   ${ok(checks.promptCacheExists)}  .ukit/storage/cache/prompt-cache.json`);
+  console.log(`[UKit]   ${ok(checks.compactHistoryExists)}  .ukit/storage/cache/compact-history.json`);
+  console.log(`[UKit]   ${ok(checks.compactPressureExists)}  .ukit/storage/cache/compact-pressure.json`);
+  console.log(`[UKit]   ${ok(checks.outputHistoryExists)}  .ukit/storage/cache/output-history.json`);
+  console.log(`[UKit]   ${ok(checks.userMemoryExists)}  .ukit/storage/memory/user.json`);
+  console.log(`[UKit]   ${ok(checks.projectMemoryDirExists)}  .ukit/storage/memory/projects/`);
+  console.log(`[UKit]   ${ok(checks.sessionMemoryDirExists)}  .ukit/storage/memory/sessions/`);
+  console.log(`[UKit]   ${ok(checks.docsProjectExists)}  docs/PROJECT.md`);
+  console.log(`[UKit]   ${ok(checks.docsMemoryExists)}  docs/MEMORY.md`);
+  console.log(`[UKit]   ${ok(checks.docsWorklogExists)}  docs/WORKLOG.md`);
+  if (codexAdapterTracked) {
+    console.log(`[UKit]   ${ok(checks.codexReadmeExists)}  .codex/README.md`);
+    console.log(`[UKit]   ${ok(checks.codexSettingsExists)}  .codex/settings.json`);
+    console.log(`[UKit]   ${ok(checks.codexSettingsLocalExists)}  .codex/settings.local.json`);
+  }
+  console.log(`[UKit]   ${ok(checks.allProvidersConfigured)}  All providers configured`);
+
+  if (runtimeConfigInspection.errors.length > 0) {
+    console.log(`[UKit] Runtime config issues: ${runtimeConfigInspection.errors.join(' | ')}`);
+  }
+
+  const allPassed = Object.values(checks).every(Boolean);
+  if (!allPassed) {
+    console.log('[UKit] Some checks failed. Run `ukit install` to fix missing files.');
+    process.exitCode = 1;
+  } else {
+    console.log('[UKit] All checks passed.');
+  }
+}

package/src/cli/commands/indexArgs.js

@@ -0,0 +1,73 @@
+const QUERY_FLAG_DEFINITIONS = new Map([['--limit', { requiresValue: true }]]);
+const TRIAGE_FLAG_DEFINITIONS = new Map();
+const CONTEXT_FLAG_DEFINITIONS = new Map([
+  ['--target', { requiresValue: true }],
+  ['--type', { requiresValue: true }],
+]);
+const VERIFY_FLAG_DEFINITIONS = new Map([
+  ['--target', { requiresValue: true }],
+  ['--type', { requiresValue: true }],
+]);
+const ROUTE_FLAG_DEFINITIONS = new Map([
+  ['--target', { requiresValue: true }],
+  ['--type', { requiresValue: true }],
+  ['--tool-command', { requiresValue: true }],
+  ['--last-prompt', { requiresValue: true }],
+  ['--adapter', { requiresValue: true }],
+]);
+
+function assertString(value) {
+  return typeof value === 'string' && value.length > 0;
+}
+
+export function parseIndexArgs(argv, flagDefinitions) {
+  const tokens = [];
+  const flags = new Map();
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+
+    if (!arg.startsWith('--')) {
+      tokens.push(arg);
+      continue;
+    }
+
+    const hasEquals = arg.includes('=');
+    const [flag, valueFromEquals = null] = hasEquals ? arg.split('=', 2) : [arg, null];
+    const definition = flagDefinitions.get(flag);
+    if (!definition) {
+      throw new Error(`Unknown option: ${flag}`);
+    }
+
+    if (definition.requiresValue) {
+      let value = valueFromEquals;
+      if (value === null) {
+        i += 1;
+        value = argv[i];
+      }
+
+      if (!assertString(value) || value.startsWith('--')) {
+        throw new Error(`Missing value for ${flag}.`);
+      }
+
+      flags.set(flag, value);
+      continue;
+    }
+
+    if (valueFromEquals !== null) {
+      throw new Error(`${flag} does not take a value.`);
+    }
+
+    flags.set(flag, true);
+  }
+
+  return { tokens, flags };
+}
+
+export {
+  QUERY_FLAG_DEFINITIONS,
+  TRIAGE_FLAG_DEFINITIONS,
+  CONTEXT_FLAG_DEFINITIONS,
+  VERIFY_FLAG_DEFINITIONS,
+  ROUTE_FLAG_DEFINITIONS,
+};