@kiipu/cli 0.0.1 → 0.0.2

package/README.md

@@ -1,21 +1,88 @@
 # Kiipu CLI
 
-`@kiipu/cli` is the publishable npm package for Kiipu local tooling.
+`@kiipu/cli` is the publishable Kiipu command line interface for local authentication, doctor checks, and direct post actions.
 
-It ships:
+## What It Does
 
-- the `kiipu` CLI
-- `kiipu skills` guidance for the Claude Code plugin package
-- `kiipu doctor`
-- direct post create/delete/restore/purge commands
+- authenticate a local machine with a Kiipu API key
+- publish posts directly from the terminal
+- delete, restore, or permanently purge posts by id
+- verify local setup and API reachability with `kiipu doctor`
+- point developers to the separate Claude Code plugin and skills packages
 
-The Kiipu CLI is the stable local control-plane entrypoint for:
+By default, the CLI talks to the production Kiipu API at `https://api.kiipu.com`.
+For local development, you can explicitly override the base URL with `KIIPU_API_URL`.
 
-- authentication
-- direct publishing actions
-- install and doctor checks
+## Install
 
-Claude Code plugin assets now publish separately from `@kiipu/claude-plugin`.
+```bash
+npm install -g @kiipu/cli
+```
+
+## Quick Start
+
+Authenticate once on the current machine:
+
+```bash
+kiipu auth login --api-key <cpk_...>
+```
+
+Create a post:
+
+```bash
+kiipu post create "Ship the beta today"
+```
+
+Check local setup:
+
+```bash
+kiipu doctor
+```
+
+## Commands
+
+```bash
+kiipu auth login --api-key <cpk_...>
+kiipu auth status
+kiipu auth logout
+
+kiipu post create "Hello Kiipu"
+kiipu post delete --id post_123
+kiipu post restore --id post_123
+kiipu post purge --id post_123
+
+kiipu doctor
+kiipu skills
+```
+
+## API Base URL
+
+The CLI uses the production Kiipu API by default:
+
+```text
+https://api.kiipu.com
+```
+
+To point the CLI at another environment during development, set `KIIPU_API_URL` explicitly:
+
+```bash
+KIIPU_API_URL=http://localhost:3001 kiipu doctor
+```
+
+The CLI no longer relies on a persisted `apiBaseUrl` in local config, which helps avoid stale non-production endpoints leaking into normal usage.
+
+## Claude Code Packages
+
+The Claude Code integration ships separately:
+
+- plugin package: `@kiipu/claude-plugin`
+- skill assets package: `@kiipu/skills`
+
+In this monorepo, you can test the plugin locally with:
+
+```bash
+claude --plugin-dir ./packages/claude-plugin
+```
 
 ## Standalone Repo Sync
 

package/dist/commands/doctor.js

@@ -1,6 +1,6 @@
 import { KiipuUserApiClient } from '../lib/kiipu-user-client.js';
 import { access } from 'node:fs/promises';
-import { getDefaultConfigPath } from '../config/config.js';
+import { DEFAULT_KIIPU_API_BASE_URL, getConfiguredApiBaseUrl, getDefaultConfigPath } from '../config/config.js';
 import { logCliEvent } from '../logger/cli-logger.js';
 export async function runDoctorCommand(config) {
     logCliEvent('doctor_start');
@@ -12,9 +12,21 @@ export async function runDoctorCommand(config) {
         };
     }
     const checks = [];
+    let ok = true;
+    const apiBaseUrlConfig = getConfiguredApiBaseUrl();
     checks.push(config.apiKey ? `OK API key: ${config.keyPrefix ?? 'configured'}` : 'Missing API key. Run `kiipu auth login --api-key <cpk_...>`.');
+    if (!(config.apiKey || process.env.KIIPU_API_KEY)) {
+        ok = false;
+    }
     checks.push(config.apiKey || process.env.KIIPU_API_KEY ? 'OK post API auth: configured' : 'Missing API key for post requests.');
-    let apiStatus = 'API unreachable';
+    checks.push(apiBaseUrlConfig.source === 'env'
+        ? `WARN API base URL override: ${config.apiBaseUrl}`
+        : `OK API base URL: ${config.apiBaseUrl}`);
+    if (apiBaseUrlConfig.source === 'default' && config.apiBaseUrl !== DEFAULT_KIIPU_API_BASE_URL) {
+        ok = false;
+        checks.push(`Config mismatch: expected ${DEFAULT_KIIPU_API_BASE_URL} but loaded ${config.apiBaseUrl}. Re-run auth to refresh local config.`);
+    }
+    let apiStatus = `API unreachable at ${config.apiBaseUrl}`;
     try {
         const response = await fetch(`${config.apiBaseUrl}/health`);
         apiStatus = response.ok ? 'API reachable' : `API returned ${response.status}`;
@@ -22,12 +34,18 @@ export async function runDoctorCommand(config) {
     catch {
         apiStatus = `API unreachable at ${config.apiBaseUrl}`;
     }
+    if (apiStatus !== 'API reachable') {
+        ok = false;
+    }
     checks.push(apiStatus);
     if (config.apiKey) {
         const authStatus = await new KiipuUserApiClient({
             apiBaseUrl: config.apiBaseUrl,
             apiKey: config.apiKey,
         }).getApiKeyMe();
+        if (!authStatus.ok) {
+            ok = false;
+        }
         checks.push(authStatus.ok ? `OK API key auth: ${authStatus.data.username}` : `API key auth failed: ${authStatus.error.message}`);
     }
     try {
@@ -35,13 +53,14 @@ export async function runDoctorCommand(config) {
         checks.push(`OK config: ${configPath}`);
     }
     catch {
+        ok = false;
         checks.push(`Missing config file: ${configPath}`);
     }
     logCliEvent('doctor_complete', {
-        ok: checks.every((line) => line.startsWith('OK') || line.includes('reachable')),
+        ok,
     });
     return {
-        ok: true,
+        ok,
         message: checks.join('\n'),
     };
 }

package/dist/commands/help.js

@@ -48,7 +48,7 @@ export function getHelpResult(command) {
                 'Examples:',
                 '  kiipu skills',
                 '  npm view @kiipu/claude-plugin version',
-                '  claude --plugin-dir ./apps/claude-plugin',
+                '  claude --plugin-dir ./packages/claude-plugin',
             ]),
         };
     }
@@ -90,7 +90,8 @@ export function getHelpResult(command) {
                 '',
                 'Checks:',
                 '  - local Kiipu config exists',
-                '  - API health and API key auth are reachable',
+                '  - production API health and API key auth are reachable by default',
+                '  - KIIPU_API_URL can explicitly override the API base URL for local development',
             ]),
         };
     }
@@ -113,7 +114,8 @@ export function getHelpResult(command) {
             '  kiipu post delete --id 123',
             '  kiipu auth login --api-key <cpk_...>',
             '  kiipu doctor',
-            '  claude --plugin-dir ./apps/claude-plugin',
+            '  claude --plugin-dir ./packages/claude-plugin',
+            '  KIIPU_API_URL=http://localhost:3001 kiipu doctor',
             '',
             'Claude Code plugin:',
             '  kiipu skills',

package/dist/commands/skills.js

@@ -4,15 +4,17 @@ export async function runSkillsCommand() {
         message: [
             'Kiipu skills',
             'Claude Code plugin package: @kiipu/claude-plugin',
-            'Local plugin directory: ./apps/claude-plugin',
+            'Skill assets package: @kiipu/skills',
             '',
             'Next actions:',
-            '  claude --plugin-dir ./apps/claude-plugin',
+            '  npm view @kiipu/skills version',
             '  npm view @kiipu/claude-plugin version',
+            '  In the monorepo: claude --plugin-dir ./packages/claude-plugin',
         ].join('\n'),
         data: {
             packageName: '@kiipu/claude-plugin',
-            pluginDir: './apps/claude-plugin',
+            skillsPackageName: '@kiipu/skills',
+            pluginDir: './packages/claude-plugin',
         },
     };
 }

package/dist/config/config.js

@@ -2,6 +2,7 @@ import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+export const DEFAULT_KIIPU_API_BASE_URL = 'https://api.kiipu.com';
 export function getKiipuConfigHome() {
     if (process.env.KIIPU_CONFIG_HOME) {
         return process.env.KIIPU_CONFIG_HOME;
@@ -11,9 +12,22 @@ export function getKiipuConfigHome() {
 export function getDefaultConfigPath() {
     return path.join(getKiipuConfigHome(), 'config.json');
 }
+export function getConfiguredApiBaseUrl() {
+    const envValue = process.env.KIIPU_API_URL?.trim();
+    if (envValue) {
+        return {
+            value: envValue,
+            source: 'env',
+        };
+    }
+    return {
+        value: DEFAULT_KIIPU_API_BASE_URL,
+        source: 'default',
+    };
+}
 export function createDefaultConfig() {
     return {
-        apiBaseUrl: process.env.KIIPU_API_URL ?? 'http://localhost:4000',
+        apiBaseUrl: getConfiguredApiBaseUrl().value,
     };
 }
 export async function loadKiipuConfig(configPath = getDefaultConfigPath()) {
@@ -23,9 +37,6 @@ export async function loadKiipuConfig(configPath = getDefaultConfigPath()) {
     const content = await readFile(configPath, 'utf8');
     const raw = JSON.parse(content);
     const nextConfig = createDefaultConfig();
-    if (typeof raw.apiBaseUrl === 'string') {
-        nextConfig.apiBaseUrl = raw.apiBaseUrl;
-    }
     if (typeof raw.apiKey === 'string') {
         nextConfig.apiKey = raw.apiKey;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kiipu/cli",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Kiipu CLI for local authentication, doctor checks, and direct post actions.",
   "license": "MIT",
   "type": "module",