@hintoai/cli 0.2.0

package/dist/api/folders.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.foldersApi = void 0;
+const foldersApi = (client) => ({
+    list: () => client.get('/folders').then((r) => r.data),
+    get: (id) => client.get(`/folders/${id}`).then((r) => r.data),
+    create: (name, parentId) => client
+        .post('/folders', { name, ...(parentId !== undefined ? { parentId } : {}) })
+        .then((r) => r.data),
+    update: (id, name) => client.put(`/folders/${id}`, { name }).then((r) => r.data),
+    delete: (id) => client.delete(`/folders/${id}`).then((r) => r.data),
+    move: (id, parentId) => client.patch(`/folders/${id}/move`, { parentId }).then((r) => r.data),
+});
+exports.foldersApi = foldersApi;

package/dist/api/generate.d.ts

@@ -0,0 +1,15 @@
+import type { AxiosInstance } from 'axios';
+export interface Job {
+    jobId: string;
+    type: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    output: unknown | null;
+    error?: string | null;
+    createdAt: string;
+    completedAt: string | null;
+}
+export declare const generateApi: (client: AxiosInstance) => {
+    start: (videoId: string, templateId?: number, callbackUrl?: string, callbackSecret?: string) => Promise<Job>;
+    status: (jobId: string) => Promise<Job>;
+    structure: (videoId: string, templateId?: number, callbackUrl?: string, callbackSecret?: string) => Promise<Job>;
+};

package/dist/api/generate.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApi = void 0;
+const generateApi = (client) => ({
+    start: (videoId, templateId, callbackUrl, callbackSecret) => client
+        .post('/generate', {
+        videoId,
+        ...(templateId !== undefined ? { templateId } : {}),
+        ...(callbackUrl ? { callbackUrl } : {}),
+        ...(callbackSecret ? { callbackSecret } : {}),
+    })
+        .then((r) => r.data),
+    status: (jobId) => client.get(`/generate/${jobId}`).then((r) => r.data),
+    structure: (videoId, templateId, callbackUrl, callbackSecret) => client
+        .post('/generate/structure', {
+        videoId,
+        ...(templateId !== undefined ? { templateId } : {}),
+        ...(callbackUrl ? { callbackUrl } : {}),
+        ...(callbackSecret ? { callbackSecret } : {}),
+    })
+        .then((r) => r.data),
+});
+exports.generateApi = generateApi;

package/dist/api/project.d.ts

@@ -0,0 +1,43 @@
+import type { AxiosInstance } from 'axios';
+export interface Project {
+    id: string;
+    name: string;
+    urlSlug: string;
+    description: string | null;
+    language: string;
+    isPublished: boolean;
+    logoUrl: string | null;
+    projectType: string;
+    isArchived: boolean;
+    createdAt: string;
+    customDomain: string | null;
+    customDomainVerified: boolean;
+}
+export interface Language {
+    code: string;
+    label: string;
+    createdAt: string;
+    translationRules: unknown | null;
+    totalArticles: number;
+    translatedArticles: number;
+    isTranslating: boolean;
+}
+export declare const projectApi: (client: AxiosInstance) => {
+    get: () => Promise<{
+        project: Project;
+    }>;
+    update: (body: {
+        name?: string;
+    }) => Promise<{
+        project: Project;
+    }>;
+    structure: () => Promise<unknown>;
+    listLanguages: () => Promise<{
+        languages: Language[];
+    }>;
+    retranslate: (code: string, callbackUrl?: string, callbackSecret?: string) => Promise<import("./generate").Job>;
+    addLanguage: (languageCode: string) => Promise<{
+        languageCode: string;
+        message: string;
+    }>;
+};

package/dist/api/project.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectApi = void 0;
+const projectApi = (client) => ({
+    get: () => client.get('/project').then((r) => r.data),
+    update: (body) => client.patch('/project', body).then((r) => r.data),
+    structure: () => client.get('/project/structure').then((r) => r.data),
+    listLanguages: () => client.get('/project/languages').then((r) => r.data),
+    retranslate: (code, callbackUrl, callbackSecret) => client
+        .post(`/project/languages/${code}/retranslate`, {
+        ...(callbackUrl ? { callbackUrl } : {}),
+        ...(callbackSecret ? { callbackSecret } : {}),
+    })
+        .then((r) => r.data),
+    addLanguage: (languageCode) => client
+        .post('/project/languages', { languageCode })
+        .then((r) => r.data),
+});
+exports.projectApi = projectApi;

package/dist/api/publish.d.ts

@@ -0,0 +1,31 @@
+import type { AxiosInstance } from 'axios';
+interface PublishStatusResponse {
+    isPublished: boolean;
+    slug: string | null;
+    url: string | null;
+    publicationId: string | null;
+    publishedAt: string | null;
+    articlesCount: number | null;
+    foldersCount: number | null;
+}
+export interface PublishStatus extends PublishStatusResponse {
+    status: 'published' | 'unpublished';
+}
+export declare const publishApi: (client: AxiosInstance) => {
+    now: (callbackUrl?: string, callbackSecret?: string) => Promise<import("./generate").Job>;
+    republish: (callbackUrl?: string, callbackSecret?: string) => Promise<import("./generate").Job>;
+    status: () => Promise<{
+        status: "published" | "unpublished";
+        isPublished: boolean;
+        slug: string | null;
+        url: string | null;
+        publicationId: string | null;
+        publishedAt: string | null;
+        articlesCount: number | null;
+        foldersCount: number | null;
+    }>;
+    unpublish: () => Promise<{
+        message: string;
+    }>;
+};
+export {};

package/dist/api/publish.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishApi = void 0;
+const publishApi = (client) => ({
+    now: (callbackUrl, callbackSecret) => client
+        .post('/publish', {
+        ...(callbackUrl ? { callbackUrl } : {}),
+        ...(callbackSecret ? { callbackSecret } : {}),
+    })
+        .then((r) => r.data),
+    republish: (callbackUrl, callbackSecret) => client
+        .post('/publish/republish', {
+        ...(callbackUrl ? { callbackUrl } : {}),
+        ...(callbackSecret ? { callbackSecret } : {}),
+    })
+        .then((r) => r.data),
+    status: () => client.get('/publish/status').then((r) => ({
+        ...r.data,
+        status: (r.data.isPublished ? 'published' : 'unpublished'),
+    })),
+    unpublish: () => client.delete('/publish').then((r) => r.data),
+});
+exports.publishApi = publishApi;

package/dist/api/templates.d.ts

@@ -0,0 +1,17 @@
+import type { AxiosInstance } from 'axios';
+export interface Template {
+    id: number;
+    name: string;
+    description?: string | null;
+    requires_video: boolean;
+    image_url?: string | null;
+    sort_order?: number | null;
+}
+export declare const templatesApi: (client: AxiosInstance) => {
+    articleTemplates: () => Promise<{
+        templates: Template[];
+    }>;
+    structureTemplates: () => Promise<{
+        templates: Template[];
+    }>;
+};

package/dist/api/templates.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templatesApi = void 0;
+const templatesApi = (client) => ({
+    articleTemplates: () => client.get('/templates/article').then((r) => r.data),
+    structureTemplates: () => client.get('/templates/structure').then((r) => r.data),
+});
+exports.templatesApi = templatesApi;

package/dist/api/videos.d.ts

@@ -0,0 +1,48 @@
+import type { AxiosInstance } from 'axios';
+export interface VideoListItem {
+    videoId: string;
+    filename?: string | null;
+    durationSeconds?: number | null;
+    status: string;
+    createdAt: string;
+}
+export interface VideoListParams {
+    offset?: number;
+    limit?: number;
+}
+export declare const videosApi: (client: AxiosInstance) => {
+    list: (params?: VideoListParams) => Promise<{
+        videos: VideoListItem[];
+        pagination: {
+            limit: number;
+            offset: number;
+            count: number;
+        };
+    }>;
+    get: (videoId: string) => Promise<{
+        videoId: string;
+        filename?: string | null;
+        status: string;
+        durationSeconds?: number | null;
+        createdAt: string;
+    }>;
+    status: (videoId: string) => Promise<{
+        videoId: string;
+        filename?: string | null;
+        status: string;
+        durationSeconds?: number | null;
+        createdAt: string;
+    }>;
+    import: (url: string, name?: string, callbackUrl?: string, callbackSecret?: string) => Promise<import("./generate").Job>;
+    uploadPresigned: (filename: string, contentType: string) => Promise<{
+        videoId: string;
+        uploadUrl: string;
+        s3Url: string;
+        key: string;
+        expiresIn: number;
+    }>;
+    uploadComplete: (videoId: string, key: string, filename: string) => Promise<{
+        videoId: string;
+    }>;
+    delete: (videoId: string) => Promise<any>;
+};

package/dist/api/videos.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.videosApi = void 0;
+const videosApi = (client) => ({
+    list: (params) => client
+        .get('/videos', { params })
+        .then((r) => r.data),
+    get: (videoId) => client
+        .get(`/videos/${videoId}`)
+        .then((r) => r.data),
+    status: (videoId) => client
+        .get(`/videos/${videoId}/status`)
+        .then((r) => r.data),
+    import: (url, name, callbackUrl, callbackSecret) => client
+        .post('/videos/import', {
+        url,
+        ...(name ? { name } : {}),
+        ...(callbackUrl ? { callbackUrl } : {}),
+        ...(callbackSecret ? { callbackSecret } : {}),
+    })
+        .then((r) => r.data),
+    uploadPresigned: (filename, contentType) => client
+        .post('/videos/upload/presigned', { filename, contentType })
+        .then((r) => r.data),
+    uploadComplete: (videoId, key, filename) => client
+        .post('/videos/upload/complete', { key, fileId: videoId, filename })
+        .then((r) => r.data),
+    delete: (videoId) => client.delete(`/videos/${videoId}`).then((r) => r.data),
+});
+exports.videosApi = videosApi;

package/dist/commands/articles.d.ts

@@ -0,0 +1,3 @@
+import type { AxiosInstance } from 'axios';
+import type { Command } from 'commander';
+export declare function registerArticles(program: Command, client: AxiosInstance): void;

package/dist/commands/articles.js

@@ -0,0 +1,297 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerArticles = registerArticles;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const articles_1 = require("../api/articles");
+const errors_1 = require("../errors");
+const output_1 = require("../output");
+function resolveContent(raw) {
+    if (!raw.startsWith('@'))
+        return raw;
+    const filePath = path_1.default.resolve(raw.slice(1));
+    return fs_1.default.readFileSync(filePath, 'utf-8');
+}
+function registerArticles(program, client) {
+    const articles = program.command('articles').description('Manage articles');
+    const api = (0, articles_1.articlesApi)(client);
+    articles
+        .command('list')
+        .description('List articles')
+        .option('--folder <id>', 'Filter by folder ID')
+        .option('--offset <n>', 'Number of articles to skip', '0')
+        .option('--limit <n>', 'Results per page', '20')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        try {
+            const data = await api.list({
+                folderId: opts.folder,
+                offset: Number(opts.offset),
+                limit: Number(opts.limit),
+            });
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printTable)(['ID', 'Title', 'Slug', 'Folder', 'Updated'], data.articles.map((a) => [
+                String(a.id),
+                a.title,
+                a.slug ?? '(none)',
+                a.folderId != null ? String(a.folderId) : '—',
+                a.updatedAt,
+            ]));
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    articles
+        .command('get <id>')
+        .description('Get an article by ID')
+        .option('--format <fmt>', 'Content format: markdown (default) or html', 'markdown')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        try {
+            const fmt = opts.format === 'html' ? 'html' : 'markdown';
+            const data = await api.get(id, fmt);
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printKeyValue)(data);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    articles
+        .command('create')
+        .description('Create an article')
+        .requiredOption('--title <title>', 'Article title')
+        .requiredOption('--content <content>', 'Markdown content string or @filepath')
+        .option('--folder <id>', 'Folder ID')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        try {
+            const data = await api.create({
+                title: opts.title,
+                content: resolveContent(opts.content),
+                folderId: opts.folder,
+            });
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printKeyValue)(data);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    articles
+        .command('create-empty')
+        .description('Create an empty article (no content required)')
+        .option('--title <title>', 'Article title')
+        .option('--folder <id>', 'Folder ID')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        try {
+            const data = await api.createEmpty({
+                ...(opts.title !== undefined && { title: opts.title }),
+                ...(opts.folder !== undefined && { folderId: Number(opts.folder) }),
+            });
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printKeyValue)(data);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    articles
+        .command('update <id>')
+        .description('Update an article')
+        .option('--title <title>', 'New title')
+        .option('--slug <slug>', 'New slug')
+        .option('--meta-description <text>', 'SEO meta description')
+        .option('--meta-keywords <keywords>', 'Comma-separated SEO keywords')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        try {
+            if (!opts.title && !opts.slug && !opts.metaDescription && !opts.metaKeywords) {
+                (0, errors_1.exitWithError)('Provide at least one field to update: --title, --slug, --meta-description, or --meta-keywords');
+                return;
+            }
+            const data = await api.update(id, {
+                ...(opts.title !== undefined && { title: opts.title }),
+                ...(opts.slug !== undefined && { slug: opts.slug }),
+                ...(opts.metaDescription !== undefined && { metaDescription: opts.metaDescription }),
+                ...(opts.metaKeywords !== undefined && {
+                    metaKeywords: opts.metaKeywords
+                        .split(',')
+                        .map((k) => k.trim())
+                        .filter(Boolean),
+                }),
+            });
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printKeyValue)(data);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    articles
+        .command('delete <id>')
+        .description('Delete an article')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        try {
+            await api.delete(id);
+            if (opts.json)
+                return (0, output_1.printJson)({ deleted: true });
+            process.stdout.write(`Article ${id} deleted.\n`);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    articles
+        .command('duplicate <id>')
+        .description('Duplicate an article')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        try {
+            const data = await api.duplicate(id);
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printKeyValue)(data);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    articles
+        .command('move <id>')
+        .description('Move an article to a folder, or to root if --folder is omitted')
+        .option('--folder <folderId>', 'Destination folder ID — omit to move to root')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        try {
+            const data = await api.move(id, opts.folder ?? null);
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printKeyValue)(data);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    articles
+        .command('regenerate <id>')
+        .description('Regenerate an article')
+        .option('--callback-url <url>', 'URL to receive a webhook when the job completes')
+        .option('--callback-secret <secret>', 'HMAC-SHA256 signing secret for the callback webhook')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        try {
+            const data = await api.regenerate(id, opts.callbackUrl, opts.callbackSecret);
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printKeyValue)(data);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    articles
+        .command('versions <id>')
+        .description('List article versions')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        try {
+            const data = await api.listVersions(id);
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printTable)(['Version ID', 'Version #', 'Created', 'Auto-save'], data.versions.map((v) => [
+                v.id,
+                String(v.versionNumber),
+                v.createdAt,
+                v.isAutoSave ? 'yes' : 'no',
+            ]));
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    articles
+        .command('restore <id>')
+        .description('Restore an article version')
+        .requiredOption('--vid <vId>', 'Version ID to restore')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        try {
+            const data = await api.restoreVersion(id, opts.vid);
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printKeyValue)(data);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    articles
+        .command('translations <id>')
+        .description('List article translations')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        try {
+            const data = await api.listTranslations(id);
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printTable)(['Language', 'Status', 'Title', 'Has Content', 'Updated'], data.translations.map((t) => [
+                t.languageCode,
+                t.status,
+                t.title ?? '—',
+                t.hasContent ? 'yes' : 'no',
+                t.updatedAt,
+            ]));
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    articles
+        .command('translate <id>')
+        .description('Get a specific translation')
+        .requiredOption('--lang <code>', 'Language code (e.g. en, fr)')
+        .option('--format <format>', 'Content format: markdown or html', /^(markdown|html)$/, 'markdown')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        try {
+            const fmt = opts.format === 'html' ? 'html' : 'markdown';
+            const data = await api.getTranslation(id, opts.lang, fmt);
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printKeyValue)(data);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    articles
+        .command('trigger-translate <id>')
+        .description('Trigger translation of an article to a language')
+        .requiredOption('--lang <code>', 'Target language code (e.g. fr, de, es)')
+        .option('--callback-url <url>', 'URL to receive a webhook when the job completes')
+        .option('--callback-secret <secret>', 'HMAC-SHA256 signing secret for the callback webhook')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        try {
+            const data = await api.triggerTranslate(id, opts.lang, opts.callbackUrl, opts.callbackSecret);
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            process.stdout.write(`Translation triggered. Job ID: ${data.jobId}\n`);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+}

package/dist/commands/completion.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerCompletion(program: Command): void;

package/dist/commands/completion.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCompletion = registerCompletion;
+const GROUPS = [
+    'videos',
+    'articles',
+    'folders',
+    'generate',
+    'project',
+    'publish',
+    'templates',
+    'export',
+    'init',
+    'completion',
+];
+const GLOBAL_FLAGS = ['--json', '--api-url', '--help', '--version'];
+function bashScript() {
+    return `# hinto bash completion
+_hinto() {
+  local cur groups flags
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  groups="${GROUPS.join(' ')}"
+  flags="${GLOBAL_FLAGS.join(' ')}"
+  if [ "\$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=( \$(compgen -W "\$groups" -- "\$cur") )
+  else
+    COMPREPLY=( \$(compgen -W "\$flags" -- "\$cur") )
+  fi
+}
+complete -F _hinto hinto
+`;
+}
+function zshScript() {
+    return `#compdef hinto
+# hinto zsh completion
+_hinto() {
+  local -a groups
+  groups=(${GROUPS.join(' ')})
+  if (( CURRENT == 2 )); then
+    compadd -- \${groups[@]}
+  else
+    compadd -- ${GLOBAL_FLAGS.join(' ')}
+  fi
+}
+compdef _hinto hinto
+`;
+}
+function fishScript() {
+    const groupLines = GROUPS.map((g) => `complete -c hinto -n "__fish_use_subcommand" -a "${g}"`).join('\n');
+    const flagLines = GLOBAL_FLAGS.map((f) => `complete -c hinto -l "${f.replace(/^--/, '')}"`).join('\n');
+    return `# hinto fish completion\n${groupLines}\n${flagLines}\n`;
+}
+function registerCompletion(program) {
+    program
+        .command('completion <shell>')
+        .description('Output a shell completion script (bash | zsh | fish)')
+        .action((shell) => {
+        switch (shell) {
+            case 'bash':
+                process.stdout.write(bashScript());
+                break;
+            case 'zsh':
+                process.stdout.write(zshScript());
+                break;
+            case 'fish':
+                process.stdout.write(fishScript());
+                break;
+            default:
+                process.stderr.write(`Unsupported shell: ${shell}. Use bash, zsh, or fish.\n`);
+                process.exit(1);
+        }
+    });
+}

package/dist/commands/export.d.ts

@@ -0,0 +1,3 @@
+import type { AxiosInstance } from 'axios';
+import type { Command } from 'commander';
+export declare function registerExport(program: Command, client: AxiosInstance): void;