@kiipu/cli 0.0.6 → 0.0.7

package/dist/commands/help.js

@@ -11,6 +11,13 @@ export function getHelpResult(command) {
                 'Usage:',
                 '  kiipu post create --content "<text>"',
                 '  kiipu post create "<text>"',
+                '  kiipu post list [--tag <tag>] [--sort <updatedAt|createdAt|title>] [--starred] [--deleted]',
+                '  kiipu post search <query>',
+                '  kiipu post search --query "<query>"',
+                '  kiipu post show --id <postId>',
+                '  kiipu post update --id <postId> --content "<text>" [--title "<title>"] [--visibility public|private] [--tags <a,b,c>]',
+                '  kiipu post star --id <postId>',
+                '  kiipu post pin --id <postId>',
                 '  kiipu post delete --id <postId>',
                 '  kiipu post restore --id <postId>',
                 '  kiipu post purge --id <postId>',
@@ -20,16 +27,36 @@ export function getHelpResult(command) {
                 '',
                 'Actions:',
                 '  create      Create a new post',
+                '  list        List your published, starred, or deleted posts',
+                '  search      Search your published posts',
+                '  show        Show one post with full metadata',
+                '  update      Update post content and metadata',
+                '  star        Toggle a post star',
+                '  pin         Toggle a post pin',
                 '  delete      Soft-delete an existing post by explicit id',
                 '  restore     Restore a deleted post by explicit id',
                 '  purge       Permanently delete a post by explicit id',
                 '',
                 'Options:',
                 '  --content "<text>"         Post content for create',
-                '  --id <postId>              Required for delete, restore, and purge',
+                '  --id <postId>              Required for show, update, star, pin, delete, restore, and purge',
+                '  --query "<query>"          Search query for post search',
+                '  --tag <tag>                Filter post list results by tag',
+                '  --sort <field>             One of updatedAt, createdAt, or title',
+                '  --starred                  List only starred posts',
+                '  --deleted                  List only deleted posts',
+                '  --title "<title>"          Optional title for post update',
+                '  --visibility <value>       Optional visibility for post update',
+                '  --tags <a,b,c>             Optional comma-separated tags for post update',
                 '',
                 'Examples:',
                 '  kiipu post create "Hello Kiipu"',
+                '  kiipu post list --sort updatedAt',
+                '  kiipu post search "roadmap"',
+                '  kiipu post show --id 123',
+                '  kiipu post update --id 123 --content "Updated text" --tags work,#notes',
+                '  kiipu post star --id 123',
+                '  kiipu post pin --id 123',
                 '  kiipu post create --content "Hello Kiipu"',
                 '  kiipu post delete --id 123',
                 '  kiipu post restore --id 123',
@@ -112,13 +139,15 @@ export function getHelpResult(command) {
             '  kiipu <command> [options]',
             '',
             'Core commands:',
-            '  post               Create, delete, restore, or purge posts with direct CLI arguments',
+            '  post               Create, browse, update, and delete posts with direct CLI arguments',
             '  auth               Manage local API key authentication',
             '  doctor             Check local setup, API access, and wrapper readiness',
             '  skills             Show where the Claude Code plugin package lives',
             '',
             'Core examples:',
             '  kiipu post create "Hello Kiipu"',
+            '  kiipu post list --starred',
+            '  kiipu post search "Hello"',
             '  kiipu post delete --id 123',
             '  kiipu auth login',
             '  kiipu doctor',

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

@@ -22,27 +22,43 @@ 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',
+    ]);
     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 +81,7 @@ 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'),
-        });
-        if (!result.ok) {
-            return printResult(action === 'create' && !(readFlag(normalizedArgs, '--content') ?? subject) ? getHelpResult('post') : result, asJson);
-        }
+        result = await runPostCommand(config, commandArgs);
         return printResult(result, asJson);
     }
     if (command === 'auth') {

package/dist/lib/kiipu-user-client.js

@@ -12,6 +12,19 @@ export class KiipuUserApiClient {
     constructor(config) {
         this.config = config;
     }
+    buildPath(path, params) {
+        if (!params) {
+            return path;
+        }
+        const search = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (typeof value === 'string' && value.length > 0) {
+                search.set(key, value);
+            }
+        }
+        const query = search.toString();
+        return query ? `${path}?${query}` : path;
+    }
     async request(path, init) {
         let response;
         try {
@@ -59,4 +72,35 @@ export class KiipuUserApiClient {
             body: JSON.stringify(input),
         });
     }
+    listPosts(input) {
+        return this.request(this.buildPath('/posts/me', input));
+    }
+    searchPosts(query) {
+        return this.request(this.buildPath('/posts/me/search', { q: query }));
+    }
+    listStarredPosts(input) {
+        return this.request(this.buildPath('/posts/me/starred', input));
+    }
+    listDeletedPosts(input) {
+        return this.request(this.buildPath('/posts/me/deleted', input));
+    }
+    getPost(id) {
+        return this.request(`/posts/${id}`);
+    }
+    updatePost(id, input) {
+        return this.request(`/posts/${id}/content`, {
+            method: 'PATCH',
+            body: JSON.stringify(input),
+        });
+    }
+    toggleStar(id) {
+        return this.request(`/posts/${id}/star`, {
+            method: 'PATCH',
+        });
+    }
+    togglePin(id) {
+        return this.request(`/posts/${id}/pin`, {
+            method: 'PATCH',
+        });
+    }
 }

package/dist/lib/post-formatters.js

@@ -0,0 +1,74 @@
+function formatTimestamp(value) {
+    if (!value) {
+        return 'unknown time';
+    }
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) {
+        return value;
+    }
+    return parsed.toLocaleString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+}
+function formatTags(tags, limit) {
+    const normalized = Array.isArray(tags)
+        ? tags
+            .map((tag) => tag.tagName?.trim())
+            .filter((tag) => Boolean(tag))
+            .slice(0, limit)
+        : [];
+    return normalized.length > 0 ? normalized.map((tag) => `#${tag}`).join(', ') : 'none';
+}
+function getPostPreview(post) {
+    const content = (post.title?.trim() || post.finalText?.trim() || post.rawText?.trim() || '').replace(/\s+/g, ' ');
+    if (!content) {
+        return '(empty)';
+    }
+    return content.length > 100 ? `${content.slice(0, 97)}...` : content;
+}
+function getStatusFlags(post) {
+    const flags = [];
+    if (post.isPinned) {
+        flags.push('pinned');
+    }
+    if (post.isStarred) {
+        flags.push('starred');
+    }
+    return flags.length > 0 ? flags.join(', ') : 'none';
+}
+export function formatPostCollection(title, posts) {
+    const lines = [title, ''];
+    if (posts.length === 0) {
+        lines.push('No posts found.');
+        return lines.join('\n');
+    }
+    for (const post of posts) {
+        lines.push(`${post.id}  ${formatTimestamp(post.updatedAt ?? post.createdAt)}`);
+        lines.push(`  flags: ${getStatusFlags(post)}  visibility: ${post.visibility}  tags: ${formatTags(post.tags, 3)}`);
+        lines.push(`  ${getPostPreview(post)}`);
+        lines.push('');
+    }
+    return lines.slice(0, -1).join('\n');
+}
+export function formatPostDetail(post) {
+    const title = post.title?.trim() || '(untitled)';
+    const body = post.finalText?.trim() || post.rawText?.trim() || '(empty)';
+    return [
+        title,
+        '',
+        body,
+        '',
+        `id: ${post.id}`,
+        `visibility: ${post.visibility}`,
+        `created: ${formatTimestamp(post.createdAt)}`,
+        `updated: ${formatTimestamp(post.updatedAt)}`,
+        `tags: ${formatTags(post.tags)}`,
+        `folder: ${post.folder ? `${post.folder.name} (${post.folder.id})` : 'none'}`,
+        `pinned: ${post.isPinned ? 'yes' : 'no'}`,
+        `starred: ${post.isStarred ? 'yes' : 'no'}`,
+    ].join('\n');
+}

package/package.json

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