@witchpot/devlog-cli 0.1.0

package/build/config.js

@@ -0,0 +1,149 @@
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readStoredToken } from "./auth/token-storage.js";
+export const CONFIG_DIR = join(homedir(), ".devlog-cli");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function isValidConfigFile(obj) {
+    if (typeof obj !== "object" || obj === null)
+        return false;
+    const c = obj;
+    if (c.activeProjectId !== undefined && typeof c.activeProjectId !== "string")
+        return false;
+    if (c.apiUrl !== undefined && typeof c.apiUrl !== "string")
+        return false;
+    return true;
+}
+function ensureConfigDir() {
+    mkdirSync(CONFIG_DIR, { mode: 0o700, recursive: true });
+}
+function loadConfigFile() {
+    try {
+        const content = readFileSync(CONFIG_FILE, "utf-8");
+        const parsed = JSON.parse(content);
+        if (!isValidConfigFile(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function saveConfigFile(config) {
+    ensureConfigDir();
+    // Merge with existing config
+    const existing = loadConfigFile() || {};
+    const merged = { ...existing, ...config };
+    writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2) + "\n", {
+        mode: 0o600,
+    });
+}
+function isLoopback(hostname) {
+    return ["localhost", "127.0.0.1", "::1"].includes(hostname);
+}
+function validateUrl(url) {
+    const cleanUrl = url.replace(/\/$/, "");
+    try {
+        const parsed = new URL(cleanUrl);
+        if (!["http:", "https:"].includes(parsed.protocol)) {
+            console.error(`Invalid URL protocol: ${parsed.protocol} -- only http/https are allowed.`);
+            process.exit(1);
+        }
+        if (parsed.protocol === "http:" && !isLoopback(parsed.hostname)) {
+            console.error(`Warning: Using unencrypted HTTP with a non-local host (${parsed.hostname}). Use HTTPS for production.`);
+            process.exit(1);
+        }
+    }
+    catch {
+        console.error(`Invalid URL: ${cleanUrl}`);
+        process.exit(1);
+    }
+    return cleanUrl;
+}
+/**
+ * Resolve configuration from flags, env vars, config file, and stored token.
+ *
+ * Priority:
+ *   1. --token flag / DEVLOG_TOKEN env var  (explicit token)
+ *   2. Stored token (from `devlog login`)
+ *   3. Neither -- error at request time
+ */
+export function resolveConfig(flags) {
+    const configFile = loadConfigFile();
+    // Resolve token
+    const explicitToken = flags["token"] || process.env.DEVLOG_TOKEN || undefined;
+    // Resolve API URL
+    const storedToken = readStoredToken();
+    const apiUrl = flags["url"] ||
+        process.env.DEVLOG_URL ||
+        configFile?.apiUrl ||
+        storedToken?.apiUrl ||
+        "https://devlog.witchpot.com";
+    const token = explicitToken || storedToken?.token || undefined;
+    return {
+        apiUrl: validateUrl(apiUrl),
+        token,
+    };
+}
+/**
+ * Get the active project ID from config.
+ * Returns the ID or exits with a helpful error message.
+ */
+export function getActiveProjectId() {
+    const config = loadConfigFile();
+    if (!config?.activeProjectId) {
+        console.error('No project specified. Run "devlog project use <id>" first, or pass a project ID as an argument.');
+        process.exit(1);
+    }
+    return config.activeProjectId;
+}
+/**
+ * Set the active project ID in config.
+ */
+export function setActiveProjectId(projectId) {
+    saveConfigFile({ activeProjectId: projectId });
+}
+/**
+ * Get the active project ID from config, or undefined if not set.
+ * Does not exit on missing -- use when the ID is optional.
+ */
+export function getActiveProjectIdOptional() {
+    const config = loadConfigFile();
+    return config?.activeProjectId;
+}
+/**
+ * Parse CLI arguments into command, positional args, and flags.
+ */
+export function parseArgs(argv) {
+    const rawArgs = argv.slice(2);
+    const command = rawArgs[0] || "help";
+    const rest = rawArgs.slice(1);
+    const flags = {};
+    const args = [];
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg.startsWith("--")) {
+            const eqIndex = arg.indexOf("=");
+            if (eqIndex !== -1) {
+                const key = arg.slice(2, eqIndex);
+                flags[key] = arg.slice(eqIndex + 1);
+            }
+            else {
+                const key = arg.slice(2);
+                const next = rest[i + 1];
+                if (next && !next.startsWith("--")) {
+                    flags[key] = next;
+                    i++;
+                }
+                else {
+                    flags[key] = "true";
+                }
+            }
+        }
+        else {
+            args.push(arg);
+        }
+    }
+    return { command, args, flags };
+}
+//# sourceMappingURL=config.js.map

package/build/errors.d.ts

@@ -0,0 +1,23 @@
+export interface ApiErrorDetail {
+    code?: string;
+    message: string;
+    hint?: string;
+}
+export declare class ApiError extends Error {
+    status: number;
+    detail: ApiErrorDetail;
+    constructor(status: number, detail: ApiErrorDetail);
+}
+/**
+ * Map HTTP status codes to CLI exit codes.
+ */
+export declare function exitCodeFromError(error: ApiError): number;
+/**
+ * Validate that an ID is safe to interpolate into a URL path.
+ * Blocks path traversal (../, /) and other injection characters.
+ */
+export declare function assertSafeId(id: string, label: string): void;
+/**
+ * Format an API error for CLI output.
+ */
+export declare function formatError(error: ApiError): string;

package/build/errors.js

@@ -0,0 +1,54 @@
+export class ApiError extends Error {
+    status;
+    detail;
+    constructor(status, detail) {
+        super(detail.message);
+        this.status = status;
+        this.detail = detail;
+        this.name = "ApiError";
+    }
+}
+/**
+ * Map HTTP status codes to CLI exit codes.
+ */
+export function exitCodeFromError(error) {
+    if (error.status === 401 || error.status === 403)
+        return 2;
+    if (error.status === 404)
+        return 3;
+    if (error.status === 409)
+        return 4;
+    if (error.status === 429)
+        return 4;
+    if (error.status >= 500)
+        return 5;
+    return 1;
+}
+const SAFE_ID_REGEX = /^[0-9a-zA-Z_-]+$/;
+/**
+ * Validate that an ID is safe to interpolate into a URL path.
+ * Blocks path traversal (../, /) and other injection characters.
+ */
+export function assertSafeId(id, label) {
+    if (!id || !SAFE_ID_REGEX.test(id)) {
+        console.error(`Invalid ${label}: ${id}`);
+        process.exit(1);
+    }
+}
+/**
+ * Format an API error for CLI output.
+ */
+export function formatError(error) {
+    const lines = [];
+    if (error.detail.code) {
+        lines.push(`Error [${error.detail.code}]: ${error.detail.message}`);
+    }
+    else {
+        lines.push(`Error: ${error.detail.message}`);
+    }
+    if (error.detail.hint) {
+        lines.push(`  Hint: ${error.detail.hint}`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=errors.js.map

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+import { parseArgs, resolveConfig } from "./config.js";
+import { DevlogClient } from "./client.js";
+import { ApiError, exitCodeFromError, formatError } from "./errors.js";
+import { getFormat } from "./output.js";
+// Auth commands
+import { loginCommand, logoutCommand, statusCommand, } from "./commands/auth.js";
+// API commands
+import { projectListCommand, projectShowCommand, projectCreateCommand, projectUpdateCommand, projectDeleteCommand, projectUseCommand, } from "./commands/projects.js";
+import { gamesListCommand, gamesAddCommand, gamesRemoveCommand, } from "./commands/games.js";
+import { historyListCommand, historyAddCommand, } from "./commands/history.js";
+import { draftListCommand, draftCreateCommand, draftUpdateCommand, draftDeleteCommand, } from "./commands/drafts.js";
+import { benchListCommand, benchAddCommand, benchRemoveCommand, } from "./commands/bench.js";
+import { eventsListCommand, eventsAddCommand, eventsRemoveCommand, } from "./commands/events.js";
+import { contextCommand } from "./commands/context.js";
+import { steamSearchCommand, steamDetailsCommand, } from "./commands/steam.js";
+const HELP = `devlog - DevLog Social Copilot CLI
+
+Usage: devlog <command> [subcommand] [options]
+
+Authentication:
+  login                    Authenticate via browser
+  logout                   Clear stored credentials
+  status                   Show authentication status
+
+Projects:
+  project list             List all projects
+  project show [id]        Show project details
+  project create           Create a new project
+  project update [id]      Update project
+  project delete <id>      Delete project
+  project use <id>         Set active project
+
+Games (Similar Games):
+  games list [projectId]   List similar games
+  games add [projectId]    Add a similar game
+  games remove [projectId] Remove a similar game
+
+History:
+  history list [projectId] List history cards
+  history add [projectId]  Add a note or milestone
+
+Drafts:
+  draft list [projectId]   List post drafts
+  draft create [projectId] Create a draft
+  draft update <draftId>   Update a draft
+  draft delete <draftId>   Delete a draft
+
+Benchmark:
+  bench list [projectId]   List benchmark accounts
+  bench add [projectId]    Add a benchmark account
+  bench remove <accountId> Remove a benchmark account
+
+Events:
+  events list [projectId]  List events
+  events add [projectId]   Add an event
+  events remove <eventId>  Remove an event
+
+Context:
+  context [projectId]      Get full project context (JSON)
+
+Steam:
+  steam search             Search Steam games
+  steam details <appid>    Get game details
+
+Options:
+  --url=<url>              DevLog URL (default: http://localhost:3000)
+  --format=json|table      Output format (default: json)
+  --token=<token>          API token (or DEVLOG_TOKEN env var)
+  help                     Show this help
+
+Examples:
+  devlog login
+  devlog project list --format=table
+  devlog project use 3f8a2b1c-...
+  devlog games list --format=table
+  devlog draft list --format=table
+  devlog context --section=games
+  devlog steam search --q=roguelike --sort=reviews_desc --limit=10
+`;
+// Commands that have subcommands (e.g. "project list", "games add")
+const COMPOUND_COMMANDS = {
+    project: {
+        list: projectListCommand,
+        show: projectShowCommand,
+        create: projectCreateCommand,
+        update: projectUpdateCommand,
+        delete: projectDeleteCommand,
+        use: projectUseCommand,
+    },
+    games: {
+        list: gamesListCommand,
+        add: gamesAddCommand,
+        remove: gamesRemoveCommand,
+    },
+    history: {
+        list: historyListCommand,
+        add: historyAddCommand,
+    },
+    draft: {
+        list: draftListCommand,
+        create: draftCreateCommand,
+        update: draftUpdateCommand,
+        delete: draftDeleteCommand,
+    },
+    bench: {
+        list: benchListCommand,
+        add: benchAddCommand,
+        remove: benchRemoveCommand,
+    },
+    events: {
+        list: eventsListCommand,
+        add: eventsAddCommand,
+        remove: eventsRemoveCommand,
+    },
+    steam: {
+        search: steamSearchCommand,
+        details: steamDetailsCommand,
+    },
+};
+// Simple top-level commands (no subcommand)
+const SIMPLE_COMMANDS = {
+    context: contextCommand,
+};
+function handleError(error, config) {
+    if (error instanceof ApiError) {
+        console.error(formatError(error));
+        process.exit(exitCodeFromError(error));
+    }
+    if (error instanceof TypeError && error.cause) {
+        const cause = error.cause;
+        if (cause.code === "ECONNREFUSED") {
+            console.error(`Connection refused: ${config.apiUrl}\nIs the DevLog app running?`);
+            process.exit(1);
+        }
+    }
+    throw error;
+}
+async function main() {
+    const { command, args, flags } = parseArgs(process.argv);
+    // Help
+    if (command === "help" || flags["help"] === "true" || !command) {
+        console.log(HELP);
+        return;
+    }
+    // Auth commands (no API client needed)
+    if (command === "login") {
+        await loginCommand(args, flags);
+        return;
+    }
+    if (command === "logout") {
+        logoutCommand();
+        return;
+    }
+    if (command === "status") {
+        statusCommand();
+        return;
+    }
+    // All other commands need authentication
+    const config = resolveConfig(flags);
+    const client = new DevlogClient(config);
+    const format = getFormat(flags);
+    // Compound commands (project list, games add, etc.)
+    const subCommands = COMPOUND_COMMANDS[command];
+    if (subCommands) {
+        const subCommand = args[0] || "list"; // default to "list"
+        const handler = subCommands[subCommand];
+        if (!handler) {
+            console.error(`Unknown subcommand: ${command} ${subCommand}`);
+            console.error('Run "devlog help" for usage.');
+            process.exit(1);
+        }
+        try {
+            await handler(client, args.slice(1), flags, format);
+        }
+        catch (error) {
+            handleError(error, config);
+        }
+        return;
+    }
+    // Simple commands
+    const simpleHandler = SIMPLE_COMMANDS[command];
+    if (simpleHandler) {
+        try {
+            await simpleHandler(client, args, flags, format);
+        }
+        catch (error) {
+            handleError(error, config);
+        }
+        return;
+    }
+    console.error(`Unknown command: ${command}`);
+    console.error('Run "devlog help" for usage.');
+    process.exit(1);
+}
+main();
+//# sourceMappingURL=index.js.map

package/build/output.d.ts

@@ -0,0 +1,13 @@
+export type OutputFormat = "json" | "table";
+/**
+ * Determine output format from flags.
+ */
+export declare function getFormat(flags: Record<string, string>): OutputFormat;
+/**
+ * Print data as formatted JSON.
+ */
+export declare function printJson(data: unknown): void;
+/**
+ * Print an array of objects as an aligned table.
+ */
+export declare function printTable(rows: Record<string, unknown>[], columns?: string[]): void;

package/build/output.js

@@ -0,0 +1,53 @@
+/**
+ * Determine output format from flags.
+ */
+export function getFormat(flags) {
+    if (flags["format"] === "table")
+        return "table";
+    return "json";
+}
+/**
+ * Print data as formatted JSON.
+ */
+export function printJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+/**
+ * Print an array of objects as an aligned table.
+ */
+export function printTable(rows, columns) {
+    if (rows.length === 0) {
+        console.log("No results found.");
+        return;
+    }
+    const cols = columns || Object.keys(rows[0]);
+    const widths = cols.map((c) => Math.max(c.length, ...rows.map((r) => {
+        const val = r[c];
+        return String(val ?? "-").length;
+    })));
+    // Cap column widths at 50 chars for readability
+    const maxWidth = 50;
+    const cappedWidths = widths.map((w) => Math.min(w, maxWidth));
+    // Header
+    console.log(cols
+        .map((c, i) => c.toUpperCase().padEnd(cappedWidths[i]))
+        .join("  "));
+    console.log(cols
+        .map((_, i) => "-".repeat(cappedWidths[i]))
+        .join("  "));
+    // Rows
+    for (const row of rows) {
+        console.log(cols
+            .map((c, i) => {
+            const val = String(row[c] ?? "-");
+            return truncate(val, cappedWidths[i]).padEnd(cappedWidths[i]);
+        })
+            .join("  "));
+    }
+}
+function truncate(str, max) {
+    if (str.length <= max)
+        return str;
+    return str.slice(0, max - 1) + "\u2026";
+}
+//# sourceMappingURL=output.js.map

package/build/types.d.ts

@@ -0,0 +1,120 @@
+/** Envelope returned by all /api/cli/* endpoints */
+export interface ApiResponse<T> {
+    data: T;
+    error?: string;
+}
+export interface Project {
+    id: string;
+    title: string | null;
+    summary: string | null;
+    status: string;
+    phase: string | null;
+    created_at: string;
+}
+export interface ProjectDetail extends Project {
+    owner_type: string;
+    owner_id: string;
+    target_audience: string | null;
+    phase_other: string | null;
+    interview_context: Record<string, unknown> | null;
+    updated_at: string;
+    project_similar_games: SimilarGame[];
+    project_repositories: ProjectRepository[];
+}
+export interface SimilarGame {
+    id?: string;
+    game_name: string;
+    steam_appid: number | null;
+    tags: string[] | null;
+    developer: string | null;
+    publisher: string | null;
+    total_reviews: number | null;
+    rating_percent: number | null;
+    website: string | null;
+    note: string | null;
+    category?: string | null;
+}
+export interface ProjectRepository {
+    repo_full_name: string;
+    default_branch: string;
+}
+export interface HistoryCard {
+    id: string;
+    project_id: string;
+    source_type: string;
+    title: string;
+    summary: string | null;
+    metadata_json: Record<string, unknown> | null;
+    media_urls: string[] | null;
+    occurred_at: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface PostDraft {
+    id: string;
+    project_id: string;
+    platform: string;
+    hook: string | null;
+    body: string;
+    hashtags: string[] | null;
+    cta: string | null;
+    status: string;
+    rationale: string | null;
+    language: string | null;
+    post_type: string | null;
+    emotional_hook: string | null;
+    cta_type: string | null;
+    media_style: string | null;
+    media_urls: string[] | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface BenchAccount {
+    id: string;
+    project_id: string;
+    platform: string;
+    handle: string;
+    source: string;
+    reason: string | null;
+    developer_name: string | null;
+    game_name: string | null;
+    steam_appid: number | null;
+    follower_count: number | null;
+    created_at: string;
+}
+export interface EventSchedule {
+    id: string;
+    project_id: string;
+    event_name: string;
+    event_date: string;
+    importance: string | null;
+}
+export interface ProjectContext {
+    project: Project;
+    games: SimilarGame[];
+    repository: ProjectRepository | null;
+    recentHistory: HistoryCard[];
+    recentDrafts: PostDraft[];
+    benchAccounts: (BenchAccount & {
+        post_count: number;
+    })[];
+    upcomingEvents: EventSchedule[];
+}
+export interface SteamSearchGame {
+    appid: number;
+    name: string;
+    priceFinal: number | null;
+    totalReviews: number | null;
+    ratingPercent: number | null;
+    releaseDate: string | null;
+    tags: string[];
+}
+export interface SteamSearchResult {
+    games: SteamSearchGame[];
+    total: number;
+    hasMore: boolean;
+    nextCursor: string | null;
+}
+import type { DevlogClient } from "./client.js";
+import type { OutputFormat } from "./output.js";
+export type CommandHandler = (client: DevlogClient, args: string[], flags: Record<string, string>, format: OutputFormat) => Promise<void>;

package/build/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@witchpot/devlog-cli",
+  "version": "0.1.0",
+  "description": "DevLog Social Copilot CLI",
+  "type": "module",
+  "main": "./build/index.js",
+  "bin": {
+    "devlog": "./build/index.js"
+  },
+  "files": [
+    "build/**/*.js",
+    "build/**/*.d.ts",
+    "!build/__tests__"
+  ],
+  "keywords": [
+    "devlog",
+    "gamedev",
+    "indie",
+    "marketing",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Witchpot/DevLogSystem.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf build",
+    "start": "node build/index.js",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "typescript": "^5",
+    "vitest": "^4.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}