@kiipu/cli 0.0.6 → 0.0.8

package/dist/commands/post.js

@@ -1,27 +1,321 @@
+import { formatPostCollection, formatPostDetail } from '../lib/post-formatters.js';
+import { KiipuUserApiClient } from '../lib/kiipu-user-client.js';
 import { executePostAction } from '../lib/post-actions.js';
-export async function runPostCommand(config, input) {
-    if (input.action === 'create') {
-        const content = input.content?.trim();
-        if (!content) {
-            return {
-                ok: false,
-                message: 'Usage: kiipu post create --content "<text>"\n   or: kiipu post create "<text>"',
-            };
-        }
-        return executePostAction(config, {
-            action: 'create',
-            content,
-        });
-    }
-    const postId = input.postId?.trim();
-    if (!postId) {
+import { hasFlag, readFlag } from '../utils/args.js';
+const actions = new Set([
+    'create',
+    'delete',
+    'restore',
+    'purge',
+    'list',
+    'search',
+    'show',
+    'update',
+    'star',
+    'pin',
+]);
+const sortValues = new Set(['updatedAt', 'createdAt', 'title']);
+function usage(action) {
+    switch (action) {
+        case 'create':
+            return 'Usage: kiipu post create --content "<text>"\n   or: kiipu post create "<text>"';
+        case 'list':
+            return 'Usage: kiipu post list [--tag <tag>] [--sort <updatedAt|createdAt|title>] [--starred] [--deleted]';
+        case 'search':
+            return 'Usage: kiipu post search <query>\n   or: kiipu post search --query "<query>"';
+        case 'show':
+            return 'Usage: kiipu post show --id <postId>';
+        case 'update':
+            return 'Usage: kiipu post update --id <postId> --content "<text>" [--title "<title>"] [--visibility public|private] [--tags <a,b,c>]';
+        case 'star':
+            return 'Usage: kiipu post star --id <postId>';
+        case 'pin':
+            return 'Usage: kiipu post pin --id <postId>';
+        default:
+            return `Usage: kiipu post ${action} --id <postId>`;
+    }
+}
+function error(message) {
+    return { ok: false, message };
+}
+function getUserClient(config) {
+    const apiKey = config.apiKey ?? process.env.KIIPU_API_KEY ?? '';
+    if (!apiKey) {
+        return null;
+    }
+    return new KiipuUserApiClient({
+        apiBaseUrl: config.apiBaseUrl,
+        apiKey,
+    });
+}
+function requireUserClient(config) {
+    const client = getUserClient(config);
+    if (!client) {
         return {
-            ok: false,
-            message: `Usage: kiipu post ${input.action} --id <postId>`,
+            error: error('Kiipu API key is missing. Run `kiipu auth login` first.'),
         };
     }
-    return executePostAction(config, {
-        action: input.action,
-        postId,
+    return { client };
+}
+function stripKnownFlags(args, flagsWithValues) {
+    const positional = [];
+    const flags = new Set(flagsWithValues);
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg) {
+            continue;
+        }
+        if (flags.has(arg)) {
+            index += 1;
+            continue;
+        }
+        if (!arg.startsWith('--')) {
+            positional.push(arg);
+        }
+    }
+    return positional;
+}
+function validateSort(sort) {
+    if (!sort) {
+        return undefined;
+    }
+    return sortValues.has(sort) ? sort : null;
+}
+function parsePostId(args, action) {
+    const postId = readFlag(args, '--id')?.trim();
+    return postId ? postId : error(usage(action));
+}
+function parseTags(input) {
+    if (!input) {
+        return undefined;
+    }
+    const unique = new Map();
+    for (const chunk of input.split(',')) {
+        const cleaned = chunk.trim().replace(/^#+/, '').replace(/\s+/g, ' ');
+        if (!cleaned) {
+            continue;
+        }
+        const normalized = cleaned.toLowerCase();
+        if (!unique.has(normalized)) {
+            unique.set(normalized, cleaned);
+        }
+        if (unique.size === 8) {
+            break;
+        }
+    }
+    return Array.from(unique.values());
+}
+function toCliPost(post) {
+    return {
+        id: post.id,
+        title: post.title,
+        rawText: post.rawText,
+        finalText: post.finalText,
+        visibility: post.visibility,
+        tags: post.tags,
+        folder: post.folder ?? null,
+        isPinned: post.isPinned,
+        isStarred: post.isStarred,
+        createdAt: post.createdAt,
+        updatedAt: post.updatedAt,
+    };
+}
+async function handleMutationAction(config, action, args) {
+    if (action === 'create') {
+        const content = (readFlag(args, '--content') ?? stripKnownFlags(args, ['--content'])[0])?.trim();
+        if (!content) {
+            return error(usage('create'));
+        }
+        return executePostAction(config, { action: 'create', content });
+    }
+    const postId = parsePostId(args, action);
+    if (typeof postId !== 'string') {
+        return postId;
+    }
+    return executePostAction(config, { action, postId });
+}
+async function handleList(config, args) {
+    const { client, error: clientError } = requireUserClient(config);
+    if (!client) {
+        return clientError;
+    }
+    const sort = validateSort(readFlag(args, '--sort'));
+    if (sort === null) {
+        return error(`Invalid --sort value. ${usage('list')}`);
+    }
+    const starred = hasFlag(args, '--starred');
+    const deleted = hasFlag(args, '--deleted');
+    if (starred && deleted) {
+        return error(`--starred and --deleted cannot be used together.\n${usage('list')}`);
+    }
+    const tag = readFlag(args, '--tag');
+    let posts;
+    let responseData;
+    if (starred) {
+        const response = await client.listStarredPosts({ tag, sort });
+        if (!response.ok) {
+            return error(response.error.message);
+        }
+        posts = response.data.map((entry) => toCliPost(entry.post));
+        responseData = response.data;
+    }
+    else if (deleted) {
+        const response = await client.listDeletedPosts({ sort });
+        if (!response.ok) {
+            return error(response.error.message);
+        }
+        posts = response.data.map(toCliPost);
+        responseData = response.data;
+    }
+    else {
+        const response = await client.listPosts({ tag, sort });
+        if (!response.ok) {
+            return error(response.error.message);
+        }
+        posts = response.data.map(toCliPost);
+        responseData = response.data;
+    }
+    const title = starred ? 'Starred posts' : deleted ? 'Deleted posts' : 'Posts';
+    return {
+        ok: true,
+        message: formatPostCollection(title, posts),
+        data: responseData,
+    };
+}
+async function handleSearch(config, args) {
+    const { client, error: clientError } = requireUserClient(config);
+    if (!client) {
+        return clientError;
+    }
+    const query = (readFlag(args, '--query') ?? stripKnownFlags(args, ['--query'])[0])?.trim();
+    if (!query) {
+        return error(usage('search'));
+    }
+    const response = await client.searchPosts(query);
+    if (!response.ok) {
+        return error(response.error.message);
+    }
+    return {
+        ok: true,
+        message: formatPostCollection(`Search results for "${query}"`, response.data.map(toCliPost)),
+        data: response.data,
+    };
+}
+async function handleShow(config, args) {
+    const { client, error: clientError } = requireUserClient(config);
+    if (!client) {
+        return clientError;
+    }
+    const postId = parsePostId(args, 'show');
+    if (typeof postId !== 'string') {
+        return postId;
+    }
+    const response = await client.getPost(postId);
+    if (!response.ok) {
+        return error(response.error.message);
+    }
+    return {
+        ok: true,
+        message: formatPostDetail(toCliPost(response.data)),
+        data: response.data,
+    };
+}
+async function handleUpdate(config, args) {
+    const { client, error: clientError } = requireUserClient(config);
+    if (!client) {
+        return clientError;
+    }
+    const postId = parsePostId(args, 'update');
+    if (typeof postId !== 'string') {
+        return postId;
+    }
+    const content = readFlag(args, '--content')?.trim();
+    if (!content) {
+        return error(usage('update'));
+    }
+    const visibility = readFlag(args, '--visibility');
+    if (visibility && visibility !== 'public' && visibility !== 'private') {
+        return error(`Invalid --visibility value. ${usage('update')}`);
+    }
+    const title = readFlag(args, '--title');
+    const tags = readFlag(args, '--tags');
+    const response = await client.updatePost(postId, {
+        rawText: content,
+        ...(title !== undefined ? { title: title || null } : {}),
+        ...(visibility === 'public' || visibility === 'private' ? { visibility } : {}),
+        ...(tags ? { tags: parseTags(tags) } : {}),
     });
+    if (!response.ok) {
+        return error(response.error.message);
+    }
+    return {
+        ok: true,
+        message: `Post updated.\n\n${formatPostDetail(toCliPost(response.data))}`,
+        data: response.data,
+    };
+}
+async function handleStar(config, args) {
+    const { client, error: clientError } = requireUserClient(config);
+    if (!client) {
+        return clientError;
+    }
+    const postId = parsePostId(args, 'star');
+    if (typeof postId !== 'string') {
+        return postId;
+    }
+    const response = await client.toggleStar(postId);
+    if (!response.ok) {
+        return error(response.error.message);
+    }
+    return {
+        ok: true,
+        message: response.data.isStarred ? `Post starred. ${response.data.id}` : `Post unstarred. ${response.data.id}`,
+        data: response.data,
+    };
+}
+async function handlePin(config, args) {
+    const { client, error: clientError } = requireUserClient(config);
+    if (!client) {
+        return clientError;
+    }
+    const postId = parsePostId(args, 'pin');
+    if (typeof postId !== 'string') {
+        return postId;
+    }
+    const response = await client.togglePin(postId);
+    if (!response.ok) {
+        return error(response.error.message);
+    }
+    return {
+        ok: true,
+        message: response.data.isPinned ? `Post pinned. ${response.data.id}` : `Post unpinned. ${response.data.id}`,
+        data: response.data,
+    };
+}
+export async function runPostCommand(config, args) {
+    const action = args[1];
+    if (!action || !actions.has(action)) {
+        return error('Usage: kiipu post <create|delete|restore|purge|list|search|show|update|star|pin> [options]');
+    }
+    const actionArgs = args.slice(2);
+    switch (action) {
+        case 'create':
+        case 'delete':
+        case 'restore':
+        case 'purge':
+            return handleMutationAction(config, action, actionArgs);
+        case 'list':
+            return handleList(config, actionArgs);
+        case 'search':
+            return handleSearch(config, actionArgs);
+        case 'show':
+            return handleShow(config, actionArgs);
+        case 'update':
+            return handleUpdate(config, actionArgs);
+        case 'star':
+            return handleStar(config, actionArgs);
+        case 'pin':
+            return handlePin(config, actionArgs);
+    }
+    return error('Unsupported post action.');
 }

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import './config/load-env.js';
 import { createDefaultConfig, loadKiipuConfig } from './config/config.js';
+import { runAskCommand } from './commands/ask.js';
 import { runAuthCommand } from './commands/auth.js';
 import { runDoctorCommand } from './commands/doctor.js';
 import { getHelpResult } from './commands/help.js';
@@ -10,7 +11,7 @@ import { readFlag, hasFlag } from './utils/args.js';
 import { CLI_VERSION } from './version.js';
 function printResult(result, asJson) {
     if (asJson) {
-        console.log(JSON.stringify(result, null, 2));
+        console.log(JSON.stringify(result.json ?? result, null, 2));
     }
     else {
         console.log(result.message);
@@ -22,27 +23,48 @@ function printResult(result, asJson) {
 async function main() {
     const args = process.argv.slice(2);
     const normalizedArgs = args[0] === '--' ? args.slice(1) : args;
+    const commandArgs = normalizedArgs.filter((arg) => arg !== '--json' && arg !== '--help' && arg !== '-h' && arg !== '--version' && arg !== '-v');
     const asJson = hasFlag(normalizedArgs, '--json');
     const wantsHelp = hasFlag(normalizedArgs, '--help') || hasFlag(normalizedArgs, '-h');
     const wantsVersion = hasFlag(normalizedArgs, '--version') || hasFlag(normalizedArgs, '-v');
+    const flagsWithValues = new Set([
+        '--scheduled-at',
+        '--package-root',
+        '--skills-dir',
+        '--text',
+        '--content',
+        '--id',
+        '--api-key',
+        '--device-name',
+        '--config-path',
+        '--wrapper-path',
+        '--conversation-id',
+        '--tag',
+        '--sort',
+        '--query',
+        '--title',
+        '--visibility',
+        '--tags',
+        '--question',
+        '--conversation-id',
+        '--top-k',
+        '--source-mode',
+        '--limit',
+    ]);
     const positionalArgs = normalizedArgs.filter((arg, index, all) => {
-        if (arg === '--json' || arg === '--help' || arg === '-h' || arg === '--version' || arg === '-v' || arg === '--no-browser')
+        if (arg === '--json' ||
+            arg === '--help' ||
+            arg === '-h' ||
+            arg === '--version' ||
+            arg === '-v' ||
+            arg === '--no-browser' ||
+            arg.startsWith('--')) {
             return false;
+        }
         const prev = all[index - 1];
-        return (prev !== '--scheduled-at' &&
-            prev !== '--package-root' &&
-            prev !== '--skills-dir' &&
-            prev !== '--text' &&
-            prev !== '--content' &&
-            prev !== '--id' &&
-            prev !== '--api-key' &&
-            prev !== '--device-name' &&
-            prev !== '--config-path' &&
-            prev !== '--wrapper-path' &&
-            prev !== '--conversation-id' &&
-            prev !== '--device-name');
+        return prev ? !flagsWithValues.has(prev) : true;
     });
-    const [command, subcommand, subject] = positionalArgs;
+    const [command, subcommand] = positionalArgs;
     if (wantsVersion) {
         console.log(CLI_VERSION);
         return;
@@ -65,19 +87,14 @@ async function main() {
         return printResult(result, asJson);
     }
     if (command === 'post') {
-        const action = subcommand;
-        if (!action || !['create', 'delete', 'restore', 'purge'].includes(action)) {
-            result = getHelpResult('post');
-            return printResult(result, asJson);
-        }
-        result = await runPostCommand(config, {
-            action,
-            content: readFlag(normalizedArgs, '--content') ?? subject,
-            postId: readFlag(normalizedArgs, '--id'),
+        result = await runPostCommand(config, commandArgs);
+        return printResult(result, asJson);
+    }
+    if (command === 'ask') {
+        result = await runAskCommand(config, commandArgs, {
+            stream: !asJson,
+            write: (chunk) => process.stdout.write(chunk),
         });
-        if (!result.ok) {
-            return printResult(action === 'create' && !(readFlag(normalizedArgs, '--content') ?? subject) ? getHelpResult('post') : result, asJson);
-        }
         return printResult(result, asJson);
     }
     if (command === 'auth') {