pokit 0.0.14 → 0.0.16

package/bin/pok.ts

@@ -55,6 +55,166 @@ function findConfigFileSimple(startDir: string): { configPath: string; configDir
   }
 }
 
+/**
+ * Simple inline package.json search.
+ */
+function findPackageJsonSimple(startDir: string): { pkgPath: string; pkgDir: string } | null {
+  let dir = startDir;
+
+  while (true) {
+    const pkgPath = path.join(dir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      return { pkgPath, pkgDir: dir };
+    }
+
+    const parentDir = path.dirname(dir);
+    if (parentDir === dir) {
+      return null;
+    }
+    dir = parentDir;
+  }
+}
+
+/**
+ * Try to resolve a module from the project directory, then from the launcher's own dependencies.
+ */
+async function resolveModule(name: string, configDir: string) {
+  try {
+    // 1. Try resolving from the project's node_modules
+    const projectModulePath = await resolve(name, configDir);
+    return await import(projectModulePath);
+  } catch {
+    try {
+      // 2. Try resolving from the launcher's own dependencies
+      return await import(name);
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Detect the package manager used in the project (simple version for launcher).
+ */
+function getPackageManagerSimple(projectRoot: string): 'npm' | 'pnpm' | 'yarn' | 'bun' {
+  if (fs.existsSync(path.join(projectRoot, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (
+    fs.existsSync(path.join(projectRoot, 'bun.lockb')) ||
+    fs.existsSync(path.join(projectRoot, 'bun.lock'))
+  )
+    return 'bun';
+  if (fs.existsSync(path.join(projectRoot, 'yarn.lock'))) return 'yarn';
+  return 'npm';
+}
+
+/**
+ * Simple dependency-free Yes/No prompt.
+ */
+async function askYesNo(question: string): Promise<boolean> {
+  if (!process.stdout.isTTY) return false;
+
+  process.stdout.write(`${question} (Y/n) `);
+  for await (const line of console) {
+    const input = line.trim().toLowerCase();
+    if (input === '' || input === 'y' || input === 'yes') return true;
+    if (input === 'n' || input === 'no') return false;
+    process.stdout.write('Please enter y or n: ');
+  }
+  return false;
+}
+
+/**
+ * Ensure required pok modules are installed in the project.
+ */
+async function ensureModulesInstalled(pkgDir: string, moduleNames: string[]): Promise<boolean> {
+  const pm = getPackageManagerSimple(pkgDir);
+  const installCmd =
+    pm === 'npm'
+      ? `npm install --save-dev ${moduleNames.join(' ')}`
+      : pm === 'pnpm'
+        ? `pnpm add -D ${moduleNames.join(' ')}`
+        : pm === 'yarn'
+          ? `yarn add -D ${moduleNames.join(' ')}`
+          : `bun add -d ${moduleNames.join(' ')}`;
+
+  const confirmed = await askYesNo(
+    `Required pok modules (${moduleNames.join(', ')}) are missing locally. Install them with ${pm}?`
+  );
+
+  if (!confirmed) return false;
+
+  console.log(`\nInstalling modules: ${installCmd}...\n`);
+
+  try {
+    const { $ } = await import('bun');
+    await $`${{ raw: installCmd }}`.cwd(pkgDir);
+    console.log('\nModules installed successfully!\n');
+    return true;
+  } catch (err) {
+    console.error(
+      `\nFailed to install modules: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return false;
+  }
+}
+
+/**
+ * Run pok in fallback mode when no config is found but package.json exists.
+ */
+async function runInFallbackMode(pkgDir: string) {
+  let core = await resolveModule('@pokit/core', pkgDir);
+  let reporter = await resolveModule('@pokit/reporter-clack', pkgDir);
+  let prompter = await resolveModule('@pokit/prompter-clack', pkgDir);
+
+  if (!core || !reporter || !prompter) {
+    const missing = [];
+    if (!core) missing.push('@pokit/core');
+    if (!reporter) missing.push('@pokit/reporter-clack');
+    if (!prompter) missing.push('@pokit/prompter-clack');
+
+    if (await ensureModulesInstalled(pkgDir, missing)) {
+      // Retry resolution after installation
+      core = await resolveModule('@pokit/core', pkgDir);
+      reporter = await resolveModule('@pokit/reporter-clack', pkgDir);
+      prompter = await resolveModule('@pokit/prompter-clack', pkgDir);
+    }
+  }
+
+  if (!core || !reporter || !prompter) {
+    console.error(
+      `Error: Required pok modules not found.\n\n` +
+        `Install them in your project to enable the fallback menu:\n` +
+        `  bun add -d @pokit/core @pokit/reporter-clack @pokit/prompter-clack\n\n` +
+        `Or run \`pok init\` to bootstrap a configuration.`
+    );
+    process.exit(1);
+  }
+
+  const { runCli, defineCommand } = core;
+  const { createReporterAdapter } = reporter;
+  const { createPrompter } = prompter;
+  const { runInit } = await import('../src/init');
+
+  await runCli(process.argv.slice(2), {
+    commandsDir: path.join(pkgDir, 'commands'),
+    projectRoot: pkgDir,
+    appName: path.basename(pkgDir),
+    reporterAdapter: createReporterAdapter(),
+    prompter: createPrompter(),
+    pmScripts: true,
+    pmCommands: true,
+    extraCommands: {
+      init: defineCommand({
+        label: 'init',
+        description: 'Initialize pok config in this repo',
+        run: async () => {
+          await runInit();
+        },
+      }),
+    },
+  });
+}
+
 async function main() {
   const processCwd = process.cwd();
 
@@ -62,7 +222,14 @@ async function main() {
   const configResult = findConfigFileSimple(processCwd);
 
   if (!configResult) {
-    console.error(`Error: No pok configuration found.
+    // Look for package.json
+    const pkgJsonResult = findPackageJsonSimple(processCwd);
+    if (pkgJsonResult) {
+      await runInFallbackMode(pkgJsonResult.pkgDir);
+      return;
+    }
+
+    console.error(`Error: No pok configuration or package.json found.
 
 Run \`pok init\` to create a pok.config.ts file.
 `);
@@ -72,12 +239,15 @@ Run \`pok init\` to create a pok.config.ts file.
   const { configPath, configDir } = configResult;
 
   // Step 2: Dynamically resolve @pokit/core from the project directory
-  let configModule: ConfigModule;
+  let configModule = await resolveModule('@pokit/core', configDir);
 
-  try {
-    const configModulePath = await resolve('@pokit/core', configDir);
-    configModule = await import(configModulePath);
-  } catch {
+  if (!configModule) {
+    if (await ensureModulesInstalled(configDir, ['@pokit/core'])) {
+      configModule = await resolveModule('@pokit/core', configDir);
+    }
+  }
+
+  if (!configModule) {
     console.error(
       `Error: @pokit/core is not installed in ${configDir}\n\n` +
         'Install it with:\n' +
@@ -107,7 +277,9 @@ Run \`pok init\` to create a pok.config.ts file.
   // Verify commands directory exists
   if (!fs.existsSync(commandsDir)) {
     console.error(`Error: Commands directory not found: ${commandsDir}\n`);
-    console.error(`The commandsDir path in ${configPath} resolves to a directory that doesn't exist.`);
+    console.error(
+      `The commandsDir path in ${configPath} resolves to a directory that doesn't exist.`
+    );
     process.exit(1);
   }
 
@@ -120,14 +292,13 @@ Run \`pok init\` to create a pok.config.ts file.
     projectRoot: cwd, // core uses projectRoot, config uses cwd
     appName: config.appName,
     version: config.version,
-     reporterAdapter: config.reporter,
-     prompter: config.prompter,
-     tabs: config.tabs,
-     pmScripts: config.pmScripts,
-     pmCommands: config.pmCommands,
-   });
- }
-
+    reporterAdapter: config.reporter,
+    prompter: config.prompter,
+    tabs: config.tabs,
+    pmScripts: config.pmScripts,
+    pmCommands: config.pmCommands,
+  });
+}
 
 main().catch((err) => {
   console.error(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pokit",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "Global CLI launcher for pok - install once, run anywhere",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,10 @@
     "access": "public"
   },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "@pokit/core": "0.0.15",
+    "@pokit/reporter-clack": "0.0.15",
+    "@pokit/prompter-clack": "0.0.15"
   },
   "engines": {
     "bun": ">=1.0.0"