social-light 0.0.1

package/src/commands/init.mjs

@@ -0,0 +1,256 @@
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import fs from "fs-extra";
+import path from "path";
+import os from "os";
+import dotenv from "dotenv";
+
+import {
+  createDefaultConfig,
+  configExists,
+  updateConfig,
+  updateCredentials,
+} from "../utils/config.mjs";
+import { initializeDb } from "../utils/db.mjs";
+
+// Load environment variables
+dotenv.config();
+
+/**
+ * Initialize the Social Light application
+ * @param {Object} argv - Command arguments
+ * @example
+ * await initialize({ force: true });
+ */
+export const initialize = async (argv) => {
+  const spinner = ora("Initializing Social Light...").start();
+
+  try {
+    const exists = configExists();
+
+    // If config already exists and not forcing re-init, prompt for confirmation
+    if (exists && !argv.force) {
+      spinner.stop();
+
+      const { confirm } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message:
+            "Social Light is already initialized. Reinitialize with default settings?",
+          default: false,
+        },
+      ]);
+
+      if (!confirm) {
+        console.log(chalk.yellow("Initialization cancelled."));
+        return;
+      }
+
+      spinner.start("Reinitializing Social Light...");
+    }
+
+    // Create default config
+    const config = createDefaultConfig();
+
+    // Initialize database first
+    spinner.text = "Setting up database...";
+    const dbInitialized = initializeDb();
+
+    if (!dbInitialized) {
+      throw new Error("Failed to initialize database");
+    }
+
+    // Configure platforms
+    spinner.text = "Setting up platforms...";
+
+    // Bluesky is the only platform we support
+    const platforms = ["Bluesky"];
+
+    // Check if we need to collect Bluesky credentials
+    spinner.text = "Checking Bluesky credentials...";
+    spinner.stop();
+
+    // Get existing credentials from .env, if available
+    const blueskyHandle = process.env.BLUESKY_HANDLE || "";
+    const blueskyPassword = process.env.BLUESKY_APP_PASSWORD || "";
+    const blueskyService = process.env.BLUESKY_SERVICE || "https://bsky.social";
+
+    console.log(chalk.cyan("\nBluesky Account Setup"));
+    console.log(
+      chalk.gray("Create an app password in your Bluesky account settings")
+    );
+
+    const { collectCredentials } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "collectCredentials",
+        message: "Would you like to set up your Bluesky credentials now?",
+        default: true,
+      },
+    ]);
+
+    let blueskyCredentials = {};
+
+    if (collectCredentials) {
+      blueskyCredentials = await inquirer.prompt([
+        {
+          type: "input",
+          name: "handle",
+          message: "Enter your Bluesky handle (username with .bsky.social):",
+          default: blueskyHandle,
+          validate: (input) =>
+            input.includes(".")
+              ? true
+              : "Handle should include domain (e.g., username.bsky.social)",
+        },
+        {
+          type: "password",
+          name: "password",
+          message:
+            "Enter your Bluesky app password (created in your Bluesky account settings):",
+          mask: "*",
+          validate: (input) =>
+            input.length > 0 ? true : "Password cannot be empty",
+        },
+        {
+          type: "input",
+          name: "service",
+          message: "Enter your Bluesky service URL:",
+          default: blueskyService,
+        },
+      ]);
+
+      // Save credentials to .env file
+      const envPath = path.join(process.cwd(), ".env");
+      let envContent = fs.existsSync(envPath)
+        ? fs.readFileSync(envPath, "utf8")
+        : "";
+
+      // Parse existing .env content
+      const envLines = envContent.split("\n");
+      const envMap = {};
+
+      envLines.forEach((line) => {
+        if (line.includes("=")) {
+          const [key, value] = line.split("=");
+          envMap[key.trim()] = value.trim();
+        }
+      });
+
+      // Update with new credentials
+      envMap["BLUESKY_HANDLE"] = blueskyCredentials.handle;
+      envMap["BLUESKY_APP_PASSWORD"] = blueskyCredentials.password;
+      envMap["BLUESKY_SERVICE"] = blueskyCredentials.service;
+
+      // Save to config.json as well
+      updateCredentials("bluesky", {
+        handle: blueskyCredentials.handle,
+        password: blueskyCredentials.password,
+        service: blueskyCredentials.service,
+      });
+
+      // If OpenAI key doesn't exist, prompt for it
+      let openaiKey = envMap["OPENAI_API_KEY"] || "";
+      if (!openaiKey) {
+        const response = await inquirer.prompt([
+          {
+            type: "input",
+            name: "openaiKey",
+            message:
+              "Enter your OpenAI API key for AI features (press Enter to skip):",
+          },
+        ]);
+
+        if (response.openaiKey) {
+          openaiKey = response.openaiKey;
+          envMap["OPENAI_API_KEY"] = openaiKey;
+        }
+      }
+
+      // Save OpenAI key to config.json
+      if (openaiKey) {
+        updateCredentials("openai", {
+          apiKey: openaiKey,
+        });
+      }
+
+      // Convert map back to env string
+      const newEnvContent = Object.entries(envMap)
+        .map(([key, value]) => `${key}=${value}`)
+        .join("\n");
+
+      // Write to .env file
+      fs.writeFileSync(envPath, newEnvContent);
+
+      console.log(
+        chalk.green("\n✓ Credentials saved to .env file and config.json")
+      );
+    }
+
+    spinner.start("Updating configuration...");
+
+    // Update config with selected platforms
+    updateConfig({ defaultPlatforms: platforms });
+
+    // Initialize database
+    spinner.text = "Setting up database...";
+    initializeDb();
+
+    spinner.succeed("Social Light initialized successfully!");
+
+    // Display configuration summary
+    console.log("\n", chalk.cyan("Configuration:"));
+    console.log(
+      ` ${chalk.gray("•")} ${chalk.bold("Database path:")} ${config.dbPath}`
+    );
+    console.log(
+      ` ${chalk.gray("•")} ${chalk.bold("Default platforms:")} ${
+        platforms.join(", ") || "None"
+      }`
+    );
+    console.log(
+      ` ${chalk.gray("•")} ${chalk.bold("AI features:")} ${
+        config.aiEnabled ? chalk.green("Enabled") : chalk.red("Disabled")
+      }`
+    );
+
+    // Display credentials info
+    const hasOpenAI = Boolean(
+      process.env.OPENAI_API_KEY || config.credentials?.openai?.apiKey
+    );
+    const hasBluesky = Boolean(
+      (process.env.BLUESKY_HANDLE && process.env.BLUESKY_APP_PASSWORD) ||
+        (config.credentials?.bluesky?.handle &&
+          config.credentials?.bluesky?.password)
+    );
+
+    console.log("\n", chalk.cyan("Credentials:"));
+    console.log(
+      ` ${chalk.gray("•")} ${chalk.bold("OpenAI API:")} ${
+        hasOpenAI ? chalk.green("Configured") : chalk.yellow("Not configured")
+      }`
+    );
+    console.log(
+      ` ${chalk.gray("•")} ${chalk.bold("Bluesky:")} ${
+        hasBluesky ? chalk.green("Configured") : chalk.yellow("Not configured")
+      }`
+    );
+
+    console.log(
+      "\n",
+      chalk.green("✓"),
+      "You're all set! Get started with",
+      chalk.cyan("social-light create")
+    );
+    console.log(
+      chalk.gray("  Need help? Run"),
+      chalk.cyan("social-light --help")
+    );
+  } catch (error) {
+    spinner.fail(`Initialization failed: ${error.message}`);
+    console.error(chalk.red("Error details:"), error);
+    process.exit(1);
+  }
+};

package/src/commands/publish.mjs

@@ -0,0 +1,192 @@
+import chalk from "chalk";
+import ora from "ora";
+import cron from "node-cron";
+import { getPosts, markAsPublished, logAction } from "../utils/db.mjs";
+import { getSocialAPI } from "../utils/social/index.mjs";
+
+/**
+ * Check if a post is eligible for publishing
+ * @param {Object} post - Post object
+ * @returns {boolean} True if post is eligible for publishing
+ */
+const isEligibleForPublishing = (post) => {
+  // If no publish date specified, it's eligible immediately
+  if (!post.publish_date) {
+    return true;
+  }
+
+  // Check if publish date is today or in the past
+  const publishDate = new Date(post.publish_date);
+  const now = new Date();
+
+  // Reset time to compare dates only
+  publishDate.setHours(0, 0, 0, 0);
+  now.setHours(0, 0, 0, 0);
+
+  return publishDate <= now;
+};
+
+/**
+ * Publish eligible posts once
+ * @returns {Promise<Array>} Array of published post IDs
+ */
+const publishEligiblePosts = async () => {
+  // Get unpublished posts
+  const posts = getPosts({ published: false });
+
+  // Filter eligible posts
+  const eligiblePosts = posts.filter(isEligibleForPublishing);
+
+  if (eligiblePosts.length === 0) {
+    return [];
+  }
+
+  // Initialize social API
+  const socialAPI = getSocialAPI();
+
+  // Track published post IDs
+  const publishedPostIds = [];
+
+  // Publish each eligible post
+  for (const post of eligiblePosts) {
+    try {
+      // Skip posts with no platforms
+      if (!post.platforms || post.platforms.trim() === "") {
+        console.log(
+          chalk.yellow(`Skipping post ID ${post.id}: No platforms specified`)
+        );
+        continue;
+      }
+
+      // Prepare platforms array
+      const platforms = post.platforms.split(",").map((p) => p.trim());
+
+      // Publish post to specified platforms
+      const result = await socialAPI.post({
+        text: post.content,
+        title: post.title,
+        platforms,
+        // Add more options as needed
+      });
+
+      // If post was successfully published to at least one platform, mark as published
+      const anySuccess = Object.values(result.results).some((r) => r.success);
+
+      if (anySuccess) {
+        markAsPublished(post.id);
+        publishedPostIds.push(post.id);
+
+        // Log the action with platform results
+        logAction("post_published", {
+          postId: post.id,
+          platforms: result.results,
+          title: post.title,
+        });
+
+        console.log(
+          chalk.green(
+            `✓ Published post ID ${post.id} to platforms: ${Object.keys(
+              result.results
+            )
+              .filter((p) => result.results[p].success)
+              .join(", ")}`
+          )
+        );
+      } else {
+        console.log(
+          chalk.red(`✗ Failed to publish post ID ${post.id} to any platform`)
+        );
+
+        // Log failures
+        for (const [platform, platformResult] of Object.entries(
+          result.results
+        )) {
+          if (!platformResult.success) {
+            console.log(chalk.red(`  - ${platform}: ${platformResult.error}`));
+          }
+        }
+      }
+    } catch (error) {
+      console.error(
+        chalk.red(`Error publishing post ID ${post.id}:`),
+        error.message
+      );
+    }
+  }
+
+  return publishedPostIds;
+};
+
+/**
+ * Publish posts command handler
+ * @param {Object} argv - Command arguments
+ */
+export const publishPosts = async (argv) => {
+  // Check if continuous mode is enabled
+  if (argv.continuous) {
+    console.log(chalk.cyan("Starting continuous publishing mode..."));
+    console.log(chalk.gray("Press Ctrl+C to stop"));
+
+    // Initial publish
+    await runContinuousPublish();
+
+    // Set up cron job to run every minute
+    cron.schedule("* * * * *", async () => {
+      await runContinuousPublish();
+    });
+
+    // Keep process alive
+    process.stdin.resume();
+  } else {
+    // One-time publish
+    const spinner = ora("Publishing eligible posts...").start();
+
+    try {
+      const publishedPostIds = await publishEligiblePosts();
+
+      if (publishedPostIds.length === 0) {
+        spinner.info("No eligible posts found for publishing.");
+      } else {
+        spinner.succeed(
+          `Published ${publishedPostIds.length} post(s) successfully!`
+        );
+        console.log(
+          chalk.gray("Run"),
+          chalk.cyan("social-light published"),
+          chalk.gray("to see published posts.")
+        );
+      }
+    } catch (error) {
+      spinner.fail(`Error publishing posts: ${error.message}`);
+      console.error(error);
+    }
+  }
+};
+
+/**
+ * Run continuous publish cycle
+ */
+const runContinuousPublish = async () => {
+  try {
+    // Get current time for logging
+    const now = new Date().toLocaleTimeString();
+
+    console.log(chalk.gray(`[${now}] Checking for posts to publish...`));
+
+    const publishedPostIds = await publishEligiblePosts();
+
+    if (publishedPostIds.length > 0) {
+      console.log(
+        chalk.green(
+          `[${now}] Published ${publishedPostIds.length} post(s) successfully!`
+        )
+      );
+    } else {
+      console.log(
+        chalk.gray(`[${now}] No eligible posts found for publishing.`)
+      );
+    }
+  } catch (error) {
+    console.error(chalk.red("Error in publishing cycle:"), error.message);
+  }
+};

package/src/commands/published.mjs

@@ -0,0 +1,90 @@
+import chalk from "chalk";
+import { getPosts } from "../utils/db.mjs";
+
+/**
+ * Format post content for display
+ * @param {string} content - Post content
+ * @param {number} maxLength - Maximum length to display
+ * @returns {string} Formatted content
+ */
+const formatContent = (content, maxLength = 60) => {
+  if (!content) return "";
+  const trimmed = content.replace(/\s+/g, " ").trim();
+  return trimmed.length > maxLength
+    ? trimmed.substring(0, maxLength) + "..."
+    : trimmed;
+};
+
+/**
+ * Format date for display
+ * @param {string} dateStr - Date string
+ * @returns {string} Formatted date
+ */
+const formatDate = (dateStr) => {
+  if (!dateStr) return "No date";
+
+  try {
+    const date = new Date(dateStr);
+    const today = new Date();
+    const yesterday = new Date(today);
+    yesterday.setDate(yesterday.getDate() - 1);
+
+    // Check if it's today or yesterday
+    if (date.toDateString() === today.toDateString()) {
+      return chalk.green("Today");
+    } else if (date.toDateString() === yesterday.toDateString()) {
+      return chalk.yellow("Yesterday");
+    }
+
+    // Format as YYYY-MM-DD
+    return date.toISOString().split("T")[0];
+  } catch (error) {
+    return dateStr; // Fallback to raw date string
+  }
+};
+
+/**
+ * List all published posts
+ * @param {Object} argv - Command arguments
+ */
+export const listPublished = async (argv) => {
+  try {
+    // Get published posts from database
+    const posts = getPosts({ published: true });
+
+    if (posts.length === 0) {
+      console.log(chalk.yellow("No published posts found."));
+      console.log(
+        chalk.gray("Run"),
+        chalk.cyan("social-light publish"),
+        chalk.gray("to publish eligible posts.")
+      );
+      return;
+    }
+
+    console.log(chalk.cyan(`\nPublished Posts (${posts.length}):`));
+    console.log(chalk.gray("─".repeat(80)));
+
+    // Display each post with index and details
+    posts.forEach((post, index) => {
+      const postNumber = chalk.bold(`[${index + 1}]`);
+      const postDate = formatDate(post.publish_date);
+      const postTitle = chalk.white(post.title || "No title");
+      const postContent = formatContent(post.content);
+      const postPlatforms = post.platforms
+        ? chalk.blue(post.platforms)
+        : chalk.gray("No platforms");
+
+      console.log(`${postNumber} ${postDate} ${postTitle}`);
+      console.log(`    ${chalk.gray(postContent)}`);
+      console.log(`    ${postPlatforms}`);
+      console.log(chalk.gray("─".repeat(80)));
+    });
+
+    console.log("");
+  } catch (error) {
+    console.error(chalk.red("Error listing published posts:"), error.message);
+    console.error(error);
+    process.exit(1);
+  }
+};

package/src/commands/unpublished.mjs

@@ -0,0 +1,102 @@
+import chalk from "chalk";
+import { getPosts } from "../utils/db.mjs";
+
+/**
+ * Format post content for display
+ * @param {string} content - Post content
+ * @param {number} maxLength - Maximum length to display
+ * @returns {string} Formatted content
+ */
+const formatContent = (content, maxLength = 60) => {
+  if (!content) return "";
+  const trimmed = content.replace(/\s+/g, " ").trim();
+  return trimmed.length > maxLength
+    ? trimmed.substring(0, maxLength) + "..."
+    : trimmed;
+};
+
+/**
+ * Format date for display
+ * @param {string} dateStr - Date string
+ * @returns {string} Formatted date
+ */
+const formatDate = (dateStr) => {
+  if (!dateStr) return "No date";
+
+  try {
+    const date = new Date(dateStr);
+    const today = new Date();
+    const tomorrow = new Date(today);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+
+    // Check if it's today or tomorrow
+    if (date.toDateString() === today.toDateString()) {
+      return chalk.green("Today");
+    } else if (date.toDateString() === tomorrow.toDateString()) {
+      return chalk.yellow("Tomorrow");
+    }
+
+    // Format as YYYY-MM-DD
+    return date.toISOString().split("T")[0];
+  } catch (error) {
+    return dateStr; // Fallback to raw date string
+  }
+};
+
+/**
+ * List all unpublished posts
+ * @param {Object} argv - Command arguments
+ */
+export const listUnpublished = async (argv) => {
+  try {
+    // Get unpublished posts from database
+    const posts = getPosts({ published: false });
+
+    if (posts.length === 0) {
+      console.log(chalk.yellow("No unpublished posts found."));
+      console.log(
+        chalk.gray("Run"),
+        chalk.cyan("social-light create"),
+        chalk.gray("to create a new post.")
+      );
+      return;
+    }
+
+    console.log(chalk.cyan(`\nUnpublished Posts (${posts.length}):`));
+    console.log(chalk.gray("─".repeat(80)));
+
+    // Display each post with index and details
+    posts.forEach((post, index) => {
+      const postNumber = chalk.bold(`[${index + 1}]`);
+      const postDate = formatDate(post.publish_date);
+      const postTitle = chalk.white(post.title || "No title");
+      const postContent = formatContent(post.content);
+      const postPlatforms = post.platforms
+        ? chalk.blue(post.platforms)
+        : chalk.gray("No platforms");
+
+      console.log(`${postNumber} ${postDate} ${postTitle}`);
+      console.log(`    ${chalk.gray(postContent)}`);
+      console.log(`    ${postPlatforms}`);
+      console.log(chalk.gray("─".repeat(80)));
+    });
+
+    // Display helpful commands
+    console.log("");
+    console.log(
+      `${chalk.green("✓")} Use ${chalk.cyan(
+        "social-light edit [index]"
+      )} to edit a post.`
+    );
+    console.log(
+      `${chalk.green("✓")} Use ${chalk.cyan(
+        "social-light publish"
+      )} to publish all eligible posts.`
+    );
+    console.log("");
+  } catch (error) {
+    console.error(chalk.red("Error listing unpublished posts:"), error.message);
+    console.error(error);
+    process.exit(1);
+  }
+};