@kiipu/cli 0.0.7 → 0.0.9

package/dist/commands/{post.js → note.js}

@@ -1,6 +1,6 @@
-import { formatPostCollection, formatPostDetail } from '../lib/post-formatters.js';
+import { formatNoteCollection, formatNoteDetail } from '../lib/note-formatters.js';
 import { KiipuUserApiClient } from '../lib/kiipu-user-client.js';
-import { executePostAction } from '../lib/post-actions.js';
+import { executeNoteAction } from '../lib/note-actions.js';
 import { hasFlag, readFlag } from '../utils/args.js';
 const actions = new Set([
     'create',
@@ -18,21 +18,21 @@ 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>"';
+            return 'Usage: kiipu note create --content "<text>"\n   or: kiipu note create "<text>"';
         case 'list':
-            return 'Usage: kiipu post list [--tag <tag>] [--sort <updatedAt|createdAt|title>] [--starred] [--deleted]';
+            return 'Usage: kiipu note list [--tag <tag>] [--sort <updatedAt|createdAt|title>] [--starred] [--deleted]';
         case 'search':
-            return 'Usage: kiipu post search <query>\n   or: kiipu post search --query "<query>"';
+            return 'Usage: kiipu note search <query>\n   or: kiipu note search --query "<query>"';
         case 'show':
-            return 'Usage: kiipu post show --id <postId>';
+            return 'Usage: kiipu note show --id <noteId>';
         case 'update':
-            return 'Usage: kiipu post update --id <postId> --content "<text>" [--title "<title>"] [--visibility public|private] [--tags <a,b,c>]';
+            return 'Usage: kiipu note update --id <noteId> --content "<text>" [--title "<title>"] [--visibility public|private] [--tags <a,b,c>]';
         case 'star':
-            return 'Usage: kiipu post star --id <postId>';
+            return 'Usage: kiipu note star --id <noteId>';
         case 'pin':
-            return 'Usage: kiipu post pin --id <postId>';
+            return 'Usage: kiipu note pin --id <noteId>';
         default:
-            return `Usage: kiipu post ${action} --id <postId>`;
+            return `Usage: kiipu note ${action} --id <noteId>`;
     }
 }
 function error(message) {
@@ -81,9 +81,9 @@ function validateSort(sort) {
     }
     return sortValues.has(sort) ? sort : null;
 }
-function parsePostId(args, action) {
-    const postId = readFlag(args, '--id')?.trim();
-    return postId ? postId : error(usage(action));
+function parseNoteId(args, action) {
+    const noteId = readFlag(args, '--id')?.trim();
+    return noteId ? noteId : error(usage(action));
 }
 function parseTags(input) {
     if (!input) {
@@ -105,19 +105,19 @@ function parseTags(input) {
     }
     return Array.from(unique.values());
 }
-function toCliPost(post) {
+function toCliNote(note) {
     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,
+        id: note.id,
+        title: note.title,
+        rawText: note.rawText,
+        finalText: note.finalText,
+        visibility: note.visibility,
+        tags: note.tags,
+        folder: note.folder ?? null,
+        isPinned: note.isPinned,
+        isStarred: note.isStarred,
+        createdAt: note.createdAt,
+        updatedAt: note.updatedAt,
     };
 }
 async function handleMutationAction(config, action, args) {
@@ -126,13 +126,13 @@ async function handleMutationAction(config, action, args) {
         if (!content) {
             return error(usage('create'));
         }
-        return executePostAction(config, { action: 'create', content });
+        return executeNoteAction(config, { action: 'create', content });
     }
-    const postId = parsePostId(args, action);
-    if (typeof postId !== 'string') {
-        return postId;
+    const noteId = parseNoteId(args, action);
+    if (typeof noteId !== 'string') {
+        return noteId;
     }
-    return executePostAction(config, { action, postId });
+    return executeNoteAction(config, { action, noteId });
 }
 async function handleList(config, args) {
     const { client, error: clientError } = requireUserClient(config);
@@ -149,36 +149,36 @@ async function handleList(config, args) {
         return error(`--starred and --deleted cannot be used together.\n${usage('list')}`);
     }
     const tag = readFlag(args, '--tag');
-    let posts;
+    let notes;
     let responseData;
     if (starred) {
-        const response = await client.listStarredPosts({ tag, sort });
+        const response = await client.listStarredNotes({ tag, sort });
         if (!response.ok) {
             return error(response.error.message);
         }
-        posts = response.data.map((entry) => toCliPost(entry.post));
+        notes = response.data.map((entry) => toCliNote(entry.note));
         responseData = response.data;
     }
     else if (deleted) {
-        const response = await client.listDeletedPosts({ sort });
+        const response = await client.listDeletedNotes({ sort });
         if (!response.ok) {
             return error(response.error.message);
         }
-        posts = response.data.map(toCliPost);
+        notes = response.data.map(toCliNote);
         responseData = response.data;
     }
     else {
-        const response = await client.listPosts({ tag, sort });
+        const response = await client.listNotes({ tag, sort });
         if (!response.ok) {
             return error(response.error.message);
         }
-        posts = response.data.map(toCliPost);
+        notes = response.data.map(toCliNote);
         responseData = response.data;
     }
-    const title = starred ? 'Starred posts' : deleted ? 'Deleted posts' : 'Posts';
+    const title = starred ? 'Starred notes' : deleted ? 'Deleted notes' : 'Notes';
     return {
         ok: true,
-        message: formatPostCollection(title, posts),
+        message: formatNoteCollection(title, notes),
         data: responseData,
     };
 }
@@ -191,13 +191,13 @@ async function handleSearch(config, args) {
     if (!query) {
         return error(usage('search'));
     }
-    const response = await client.searchPosts(query);
+    const response = await client.searchNotes(query);
     if (!response.ok) {
         return error(response.error.message);
     }
     return {
         ok: true,
-        message: formatPostCollection(`Search results for "${query}"`, response.data.map(toCliPost)),
+        message: formatNoteCollection(`Search results for "${query}"`, response.data.map(toCliNote)),
         data: response.data,
     };
 }
@@ -206,17 +206,17 @@ async function handleShow(config, args) {
     if (!client) {
         return clientError;
     }
-    const postId = parsePostId(args, 'show');
-    if (typeof postId !== 'string') {
-        return postId;
+    const noteId = parseNoteId(args, 'show');
+    if (typeof noteId !== 'string') {
+        return noteId;
     }
-    const response = await client.getPost(postId);
+    const response = await client.getNote(noteId);
     if (!response.ok) {
         return error(response.error.message);
     }
     return {
         ok: true,
-        message: formatPostDetail(toCliPost(response.data)),
+        message: formatNoteDetail(toCliNote(response.data)),
         data: response.data,
     };
 }
@@ -225,9 +225,9 @@ async function handleUpdate(config, args) {
     if (!client) {
         return clientError;
     }
-    const postId = parsePostId(args, 'update');
-    if (typeof postId !== 'string') {
-        return postId;
+    const noteId = parseNoteId(args, 'update');
+    if (typeof noteId !== 'string') {
+        return noteId;
     }
     const content = readFlag(args, '--content')?.trim();
     if (!content) {
@@ -239,7 +239,7 @@ async function handleUpdate(config, args) {
     }
     const title = readFlag(args, '--title');
     const tags = readFlag(args, '--tags');
-    const response = await client.updatePost(postId, {
+    const response = await client.updateNote(noteId, {
         rawText: content,
         ...(title !== undefined ? { title: title || null } : {}),
         ...(visibility === 'public' || visibility === 'private' ? { visibility } : {}),
@@ -250,7 +250,7 @@ async function handleUpdate(config, args) {
     }
     return {
         ok: true,
-        message: `Post updated.\n\n${formatPostDetail(toCliPost(response.data))}`,
+        message: `Note updated.\n\n${formatNoteDetail(toCliNote(response.data))}`,
         data: response.data,
     };
 }
@@ -259,17 +259,19 @@ async function handleStar(config, args) {
     if (!client) {
         return clientError;
     }
-    const postId = parsePostId(args, 'star');
-    if (typeof postId !== 'string') {
-        return postId;
+    const noteId = parseNoteId(args, 'star');
+    if (typeof noteId !== 'string') {
+        return noteId;
     }
-    const response = await client.toggleStar(postId);
+    const response = await client.toggleStar(noteId);
     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}`,
+        message: response.data.isStarred
+            ? `Note starred. ${response.data.id}`
+            : `Note unstarred. ${response.data.id}`,
         data: response.data,
     };
 }
@@ -278,24 +280,26 @@ async function handlePin(config, args) {
     if (!client) {
         return clientError;
     }
-    const postId = parsePostId(args, 'pin');
-    if (typeof postId !== 'string') {
-        return postId;
+    const noteId = parseNoteId(args, 'pin');
+    if (typeof noteId !== 'string') {
+        return noteId;
     }
-    const response = await client.togglePin(postId);
+    const response = await client.togglePin(noteId);
     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}`,
+        message: response.data.isPinned
+            ? `Note pinned. ${response.data.id}`
+            : `Note unpinned. ${response.data.id}`,
         data: response.data,
     };
 }
-export async function runPostCommand(config, args) {
+export async function runNoteCommand(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]');
+        return error('Usage: kiipu note <create|delete|restore|purge|list|search|show|update|star|pin> [options]');
     }
     const actionArgs = args.slice(2);
     switch (action) {
@@ -317,5 +321,5 @@ export async function runPostCommand(config, args) {
         case 'pin':
             return handlePin(config, actionArgs);
     }
-    return error('Unsupported post action.');
+    return error('Unsupported note action.');
 }

package/dist/config/load-env.js

@@ -13,7 +13,10 @@ function parseEnvFile(content) {
         if (!key || process.env[key] !== undefined) {
             continue;
         }
-        const value = line.slice(separatorIndex + 1).trim().replace(/^['"]|['"]$/g, '');
+        const value = line
+            .slice(separatorIndex + 1)
+            .trim()
+            .replace(/^['"]|['"]$/g, '');
         process.env[key] = value;
     }
 }

package/dist/index.js

@@ -1,16 +1,17 @@
 #!/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';
-import { runPostCommand } from './commands/post.js';
+import { runNoteCommand } from './commands/note.js';
 import { runSkillsCommand } from './commands/skills.js';
 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);
@@ -44,6 +45,11 @@ async function main() {
         '--title',
         '--visibility',
         '--tags',
+        '--question',
+        '--conversation-id',
+        '--top-k',
+        '--source-mode',
+        '--limit',
     ]);
     const positionalArgs = normalizedArgs.filter((arg, index, all) => {
         if (arg === '--json' ||
@@ -80,8 +86,15 @@ async function main() {
         result = await runDoctorCommand(await loadKiipuConfig());
         return printResult(result, asJson);
     }
-    if (command === 'post') {
-        result = await runPostCommand(config, commandArgs);
+    if (command === 'note') {
+        result = await runNoteCommand(config, commandArgs);
+        return printResult(result, asJson);
+    }
+    if (command === 'ask') {
+        result = await runAskCommand(config, commandArgs, {
+            stream: !asJson,
+            write: (chunk) => process.stdout.write(chunk),
+        });
         return printResult(result, asJson);
     }
     if (command === 'auth') {

package/dist/lib/ask-client.js

@@ -0,0 +1,278 @@
+import { TextDecoder } from 'node:util';
+function isRecord(input) {
+    return typeof input === 'object' && input !== null;
+}
+function buildError(message, code = 'request_failed') {
+    return {
+        ok: false,
+        error: {
+            code,
+            message,
+        },
+    };
+}
+function getErrorMessage(payload, fallback) {
+    if (!isRecord(payload)) {
+        return fallback;
+    }
+    if (typeof payload.message === 'string') {
+        return payload.message;
+    }
+    if (isRecord(payload.message) && typeof payload.message.message === 'string') {
+        return payload.message.message;
+    }
+    if (isRecord(payload.error) && typeof payload.error.message === 'string') {
+        return payload.error.message;
+    }
+    return fallback;
+}
+function getErrorCode(payload, fallback = 'request_failed') {
+    if (!isRecord(payload)) {
+        return fallback;
+    }
+    if (typeof payload.code === 'string') {
+        return payload.code;
+    }
+    if (isRecord(payload.message) && typeof payload.message.code === 'string') {
+        return payload.message.code;
+    }
+    if (isRecord(payload.error) && typeof payload.error.code === 'string') {
+        return payload.error.code;
+    }
+    return fallback;
+}
+function parseSource(input) {
+    if (!isRecord(input)) {
+        return null;
+    }
+    const noteId = typeof input.noteId === 'string' ? input.noteId : '';
+    const snippet = typeof input.snippet === 'string' ? input.snippet : '';
+    if (!noteId || !snippet) {
+        return null;
+    }
+    return {
+        index: typeof input.index === 'number' ? input.index : 0,
+        noteId,
+        title: typeof input.title === 'string' ? input.title : null,
+        snippet,
+        score: typeof input.score === 'number' ? input.score : 0,
+        createdAt: typeof input.createdAt === 'string' ? input.createdAt : undefined,
+    };
+}
+function parseSources(input) {
+    return Array.isArray(input)
+        ? input.map(parseSource).filter((source) => Boolean(source))
+        : [];
+}
+function parseAskEvent(input) {
+    if (!isRecord(input) || typeof input.type !== 'string') {
+        return null;
+    }
+    switch (input.type) {
+        case 'meta':
+            if (typeof input.conversationId !== 'string') {
+                return null;
+            }
+            return {
+                type: 'meta',
+                conversationId: input.conversationId,
+                isNew: Boolean(input.isNew),
+                title: typeof input.title === 'string' ? input.title : null,
+            };
+        case 'sources':
+            return {
+                type: 'sources',
+                sources: parseSources(input.sources),
+                locked: Boolean(input.locked),
+                retrievalMode: input.retrievalMode === 'semantic' || input.retrievalMode === 'temporal_list'
+                    ? input.retrievalMode
+                    : undefined,
+                totalCount: typeof input.totalCount === 'number' ? input.totalCount : undefined,
+                truncated: typeof input.truncated === 'boolean' ? input.truncated : undefined,
+            };
+        case 'delta':
+            return typeof input.text === 'string' ? { type: 'delta', text: input.text } : null;
+        case 'done':
+            if (typeof input.turnId !== 'string') {
+                return null;
+            }
+            return {
+                type: 'done',
+                turnId: input.turnId,
+                inputTokens: typeof input.inputTokens === 'number' ? input.inputTokens : 0,
+                outputTokens: typeof input.outputTokens === 'number' ? input.outputTokens : 0,
+                latencyMs: typeof input.latencyMs === 'number' ? input.latencyMs : 0,
+            };
+        case 'title':
+            if (typeof input.conversationId !== 'string' || typeof input.title !== 'string') {
+                return null;
+            }
+            return { type: 'title', conversationId: input.conversationId, title: input.title };
+        case 'error':
+            return {
+                type: 'error',
+                code: typeof input.code === 'string' ? input.code : 'unknown',
+                message: typeof input.message === 'string' ? input.message : 'Unknown Ask error.',
+            };
+        default:
+            return null;
+    }
+}
+function extractDataField(frame) {
+    const dataLines = [];
+    for (const line of frame.split('\n')) {
+        const normalized = line.endsWith('\r') ? line.slice(0, -1) : line;
+        if (normalized.startsWith('data:')) {
+            dataLines.push(normalized.slice(5).replace(/^ /, ''));
+        }
+    }
+    return dataLines.length > 0 ? dataLines.join('\n') : null;
+}
+async function readJson(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+}
+export class KiipuAskClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async requestJson(path, init) {
+        let response;
+        try {
+            response = await fetch(`${this.config.apiBaseUrl}${path}`, {
+                ...init,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                    ...(init.headers ?? {}),
+                },
+            });
+        }
+        catch {
+            return buildError(`Kiipu API is unreachable at ${this.config.apiBaseUrl}.`, 'api_unreachable');
+        }
+        const payload = await readJson(response);
+        if (!response.ok) {
+            return buildError(getErrorMessage(payload, `Request failed with ${response.status}.`), getErrorCode(payload, `http_${response.status}`));
+        }
+        const data = isRecord(payload) && 'data' in payload ? payload.data : payload;
+        return {
+            ok: true,
+            data: data,
+        };
+    }
+    listConversations(input) {
+        const search = new URLSearchParams();
+        if (input.query) {
+            search.set('q', input.query);
+        }
+        if (input.limit) {
+            search.set('limit', String(input.limit));
+        }
+        if (input.archived) {
+            search.set('view', 'archived');
+        }
+        const query = search.toString();
+        return this.requestJson(`/ai/conversations${query ? `?${query}` : ''}`, { method: 'GET' });
+    }
+    getConversation(id) {
+        return this.requestJson(`/ai/conversations/${encodeURIComponent(id)}`, {
+            method: 'GET',
+        });
+    }
+    async *streamMessage(input) {
+        const body = {
+            question: input.question,
+            ...(input.topK ? { topK: input.topK } : {}),
+            ...(input.sourceMode ? { sourceMode: input.sourceMode } : {}),
+        };
+        let response;
+        try {
+            response = await fetch(`${this.config.apiBaseUrl}/ai/conversations/${encodeURIComponent(input.conversationId)}/messages`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                    Accept: 'text/event-stream',
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (error) {
+            yield {
+                type: 'error',
+                code: 'network_error',
+                message: error instanceof Error ? error.message : 'Network request failed.',
+            };
+            return;
+        }
+        if (!response.ok || !response.body) {
+            const payload = await readJson(response);
+            yield {
+                type: 'error',
+                code: getErrorCode(payload, `http_${response.status}`),
+                message: getErrorMessage(payload, `Request failed with ${response.status}.`),
+            };
+            return;
+        }
+        let settled = false;
+        const decoder = new TextDecoder();
+        const reader = response.body.getReader();
+        let buffer = '';
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                let separator = buffer.indexOf('\n\n');
+                while (separator !== -1) {
+                    const frame = buffer.slice(0, separator);
+                    buffer = buffer.slice(separator + 2);
+                    const data = extractDataField(frame);
+                    if (data && data !== '[DONE]') {
+                        try {
+                            const event = parseAskEvent(JSON.parse(data));
+                            if (event) {
+                                if (event.type === 'done' || event.type === 'error') {
+                                    settled = true;
+                                }
+                                yield event;
+                            }
+                        }
+                        catch {
+                            // Ignore malformed SSE frames from intermediaries.
+                        }
+                    }
+                    separator = buffer.indexOf('\n\n');
+                }
+            }
+        }
+        catch (error) {
+            if (!settled) {
+                yield {
+                    type: 'error',
+                    code: 'stream_error',
+                    message: error instanceof Error ? error.message : 'Stream interrupted.',
+                };
+            }
+            return;
+        }
+        finally {
+            reader.releaseLock();
+        }
+        if (!settled) {
+            yield {
+                type: 'error',
+                code: 'stream_truncated',
+                message: 'The response ended unexpectedly. Please try again.',
+            };
+        }
+    }
+}