social-light 0.0.1

package/src/commands/create.mjs

@@ -0,0 +1,274 @@
+import fs from "fs-extra";
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import path from "path";
+import os from "os";
+
+import { getConfig, configExists } from "../utils/config.mjs";
+import {
+  createPost as dbCreatePost,
+  logAction,
+  initializeDb,
+} from "../utils/db.mjs";
+import {
+  generateTitle,
+  suggestPublishDate,
+  enhanceContent,
+} from "../utils/ai.mjs";
+
+/**
+ * Create a new social media post
+ * @param {Object} argv - Command arguments
+ * @example
+ * await createPost({ file: 'my-post.txt' });
+ */
+export const createPost = async (argv) => {
+  const config = getConfig();
+  let content = "";
+
+  try {
+    // Check if initialized and initialize if needed
+    if (!configExists()) {
+      console.log(chalk.yellow("Social Light is not initialized yet."));
+      console.log("Initializing with default settings...");
+
+      // Create config directory
+      const configDir = path.join(os.homedir(), ".social-light");
+      fs.ensureDirSync(configDir);
+
+      // Initialize database
+      const dbInitialized = initializeDb();
+      if (!dbInitialized) {
+        throw new Error("Failed to initialize database");
+      }
+    }
+    // File-based creation
+    if (argv.file) {
+      const spinner = ora(`Reading file ${argv.file}...`).start();
+
+      try {
+        content = await fs.readFile(argv.file, "utf8");
+        spinner.succeed(`File ${argv.file} loaded successfully!`);
+      } catch (error) {
+        spinner.fail(`Failed to read file: ${error.message}`);
+        process.exit(1);
+      }
+    }
+    // Interactive creation
+    else {
+      // Function to handle input with 3 empty lines to end
+      const getContentInput = async (prompt) => {
+        console.log(`${prompt} (Press Enter 3 times in a row when done)`);
+        let lines = [];
+        let emptyLineCount = 0;
+
+        // Set up recursive prompt for input
+        const promptLine = async () => {
+          const { input } = await inquirer.prompt([
+            {
+              type: "input",
+              name: "input",
+              message: ">",
+            },
+          ]);
+
+          // Check for empty line
+          if (input.trim() === "") {
+            emptyLineCount++;
+
+            // If we have 3 consecutive empty lines, we're done
+            if (emptyLineCount >= 3) {
+              // Remove the last empty lines (if any) from the result
+              while (
+                lines.length > 0 &&
+                lines[lines.length - 1].trim() === ""
+              ) {
+                lines.pop();
+              }
+              console.log(chalk.green("\n✓ Content input complete"));
+              return lines.join("\n");
+            }
+          } else {
+            // Reset empty line counter when non-empty input is received
+            emptyLineCount = 0;
+          }
+
+          lines.push(input);
+          return promptLine();
+        };
+
+        return promptLine();
+      };
+
+      // Get post content
+      content = await getContentInput("Enter your post content:");
+    }
+
+    // Generate title with AI or prompt for manual entry
+    let spinner = ora("Generating title suggestion...").start();
+    let title = "";
+
+    if (config.aiEnabled) {
+      title = await generateTitle(content);
+      spinner.succeed("Title suggestion generated");
+    } else {
+      spinner.info("AI is disabled, skipping title generation");
+    }
+
+    // Allow manual title override
+    const { titleInput } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "titleInput",
+        message: "Enter post title (or press Enter to use suggestion):",
+        default: title,
+      },
+    ]);
+
+    title = titleInput;
+
+    // Generate publish date with AI or prompt for manual entry
+    spinner = ora("Suggesting publish date...").start();
+    let publishDate = "";
+
+    if (config.aiEnabled) {
+      publishDate = await suggestPublishDate();
+      spinner.succeed(`Suggested publish date: ${publishDate}`);
+    } else {
+      spinner.info("AI is disabled, skipping date suggestion");
+    }
+
+    // Allow manual date override
+    const { dateInput } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "dateInput",
+        message:
+          "Enter publish date (YYYY-MM-DD) or press Enter to use suggestion:",
+        default: publishDate,
+        validate: (input) => {
+          if (!input) return true;
+          return /^\d{4}-\d{2}-\d{2}$/.test(input)
+            ? true
+            : "Please use YYYY-MM-DD format";
+        },
+      },
+    ]);
+
+    publishDate = dateInput;
+
+    // Select platforms
+    const { selectedPlatforms } = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "selectedPlatforms",
+        message: "Select platforms to publish to:",
+        choices: [
+          {
+            name: "Bluesky",
+            value: "Bluesky",
+            checked: config.defaultPlatforms.includes("Bluesky"),
+          },
+        ],
+      },
+    ]);
+
+    const platforms = selectedPlatforms.join(",");
+
+    // Option to enhance content for the primary platform
+    if (config.aiEnabled && selectedPlatforms.length > 0) {
+      const primaryPlatform = selectedPlatforms[0];
+
+      const { enhance } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "enhance",
+          message: `Would you like AI to enhance your content for ${primaryPlatform}?`,
+          default: false,
+        },
+      ]);
+
+      if (enhance) {
+        spinner = ora(`Enhancing content for ${primaryPlatform}...`).start();
+        const enhancedContent = await enhanceContent(content, primaryPlatform);
+
+        if (enhancedContent !== content) {
+          spinner.succeed("Content enhanced");
+
+          // Show the original and enhanced versions
+          console.log("\n", chalk.cyan("Original:"), chalk.gray(content));
+          console.log(
+            "\n",
+            chalk.cyan("Enhanced:"),
+            chalk.white(enhancedContent)
+          );
+
+          const { useEnhanced } = await inquirer.prompt([
+            {
+              type: "confirm",
+              name: "useEnhanced",
+              message: "Use the enhanced version?",
+              default: true,
+            },
+          ]);
+
+          if (useEnhanced) {
+            content = enhancedContent;
+          }
+        } else {
+          spinner.info("No significant enhancements suggested");
+        }
+      }
+    }
+
+    // Create post in database
+    spinner = ora("Saving post...").start();
+
+    const postId = dbCreatePost({
+      title,
+      content,
+      platforms,
+      publish_date: publishDate,
+    });
+
+    // Log the action
+    logAction("post_created", {
+      postId,
+      title,
+      platforms: selectedPlatforms,
+      publishDate,
+    });
+
+    spinner.succeed(`Post created successfully with ID: ${postId}`);
+
+    // Summary
+    console.log("\n", chalk.cyan("Post Summary:"));
+    console.log(` ${chalk.gray("•")} ${chalk.bold("Title:")} ${title}`);
+    console.log(
+      ` ${chalk.gray("•")} ${chalk.bold("Platforms:")} ${platforms || "None"}`
+    );
+    console.log(
+      ` ${chalk.gray("•")} ${chalk.bold("Publish Date:")} ${
+        publishDate || "Not scheduled"
+      }`
+    );
+    console.log(
+      ` ${chalk.gray("•")} ${chalk.bold("Content:")} ${content.substring(
+        0,
+        50
+      )}${content.length > 50 ? "..." : ""}`
+    );
+
+    console.log("\n", chalk.green("✓"), "Post created successfully!");
+    console.log(
+      chalk.gray("  Run"),
+      chalk.cyan("social-light unpublished"),
+      chalk.gray("to see your scheduled posts")
+    );
+  } catch (error) {
+    console.error(chalk.red("Error creating post:"), error.message);
+    console.error(error);
+    process.exit(1);
+  }
+};

package/src/commands/edit.mjs

@@ -0,0 +1,198 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { getPosts, getPostById, updatePost, logAction } from "../utils/db.mjs";
+import { getConfig } from "../utils/config.mjs";
+
+/**
+ * Edit a draft post by index
+ * @param {Object} argv - Command arguments
+ */
+export const editPost = async (argv) => {
+  try {
+    // Get unpublished posts
+    const posts = getPosts({ published: false });
+
+    if (posts.length === 0) {
+      console.log(chalk.yellow("No unpublished posts found to edit."));
+      console.log(
+        chalk.gray("Run"),
+        chalk.cyan("social-light create"),
+        chalk.gray("to create a new post.")
+      );
+      return;
+    }
+
+    // Determine which post to edit
+    let postIndex = argv.index;
+
+    // If no index provided, prompt user to select a post
+    if (postIndex === undefined) {
+      const { selectedIndex } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "selectedIndex",
+          message: "Select a post to edit:",
+          choices: posts.map((post, index) => ({
+            name: `[${index + 1}] ${
+              post.title || "No title"
+            } - ${post.content.substring(0, 40)}...`,
+            value: index + 1,
+          })),
+        },
+      ]);
+
+      postIndex = selectedIndex;
+    }
+
+    // Validate post index
+    if (postIndex < 1 || postIndex > posts.length) {
+      console.error(
+        chalk.red(`Invalid post index. Must be between 1 and ${posts.length}.`)
+      );
+      process.exit(1);
+    }
+
+    // Get post by ID
+    const post = getPostById(posts[postIndex - 1].id);
+
+    if (!post) {
+      console.error(chalk.red("Post not found."));
+      process.exit(1);
+    }
+
+    // Function to handle multiline input
+    const getMultilineInput = async (prompt, defaultText) => {
+      console.log(`${prompt} (Type 'EOF' on a new line when done)`);
+      console.log(`Current content: ${defaultText}`);
+      console.log("Enter new content:");
+
+      let lines = [];
+
+      // Set up recursive prompt for multiline input
+      const promptLine = async () => {
+        const { input } = await inquirer.prompt([
+          {
+            type: "input",
+            name: "input",
+            message: ">",
+          },
+        ]);
+
+        if (input === "EOF") {
+          return lines.length > 0 ? lines.join("\n") : defaultText;
+        }
+
+        lines.push(input);
+        return promptLine();
+      };
+
+      return promptLine();
+    };
+
+    // Ask if user wants to edit with multiline input
+    const { useMultiline } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "useMultiline",
+        message: "Would you like to edit content with multiline input?",
+        default: true,
+      },
+    ]);
+
+    // Get title
+    const { title } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "title",
+        message: "Edit title:",
+        default: post.title || "",
+      },
+    ]);
+
+    // Get content based on user preference
+    let content;
+    if (useMultiline) {
+      content = await getMultilineInput("Edit content:", post.content);
+    } else {
+      const result = await inquirer.prompt([
+        {
+          type: "input",
+          name: "content",
+          message: "Edit content:",
+          default: post.content,
+        },
+      ]);
+      content = result.content;
+    }
+
+    // Get publish date and platforms
+    const { publishDate, platforms } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "publishDate",
+        message: "Edit publish date (YYYY-MM-DD):",
+        default: post.publish_date || "",
+        validate: (input) => {
+          if (!input) return true;
+          return /^\d{4}-\d{2}-\d{2}$/.test(input)
+            ? true
+            : "Please use YYYY-MM-DD format";
+        },
+      },
+      {
+        type: "checkbox",
+        name: "platforms",
+        message: "Select platforms to publish to:",
+        choices: [
+          // { name: 'Twitter', value: 'Twitter', checked: post.platforms && post.platforms.includes('Twitter') },
+          {
+            name: "Bluesky",
+            value: "Bluesky",
+            checked: post.platforms && post.platforms.includes("Bluesky"),
+          },
+          // { name: 'TikTok', value: 'TikTok', checked: post.platforms && post.platforms.includes('TikTok') },
+          // { name: 'Instagram', value: 'Instagram', checked: post.platforms && post.platforms.includes('Instagram') },
+          // { name: 'LinkedIn', value: 'LinkedIn', checked: post.platforms && post.platforms.includes('LinkedIn') }
+        ],
+      },
+    ]);
+
+    const config = getConfig();
+
+    // Update post in database
+    const updatedPost = {
+      title,
+      content,
+      platforms: platforms.join(","),
+      publish_date: publishDate,
+    };
+
+    const success = updatePost(post.id, updatedPost);
+
+    if (success) {
+      // Log the action
+      logAction("post_edited", {
+        postId: post.id,
+        title: title,
+      });
+
+      console.log(chalk.green("\n✓ Post updated successfully!"));
+      console.log(
+        chalk.gray("Run"),
+        chalk.cyan("social-light unpublished"),
+        chalk.gray("to see your updated post.")
+      );
+      console.log(
+        chalk.gray("Run"),
+        chalk.cyan("social-light publish"),
+        chalk.gray("to publish eligible posts.")
+      );
+    } else {
+      console.error(chalk.red("Failed to update post."));
+    }
+  } catch (error) {
+    console.error(chalk.red("Error editing post:"), error.message);
+    console.error(error);
+    process.exit(1);
+  }
+};