social-light 0.1.3 → 0.1.4

package/CLAUDE.md

@@ -0,0 +1,113 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Social Light is an AI-powered social media scheduling tool for Bluesky (with more platforms planned). It provides both a CLI and web interface for creating, scheduling, and publishing posts.
+
+## Commands
+
+### Development Commands
+
+```bash
+# Install dependencies
+npm install
+
+# Run CLI in development mode (with auto-restart)
+npm run dev
+
+# Start the web server
+npm run server
+# OR with custom port
+node src/server/index.mjs --port 8080
+
+# Make CLI globally available
+chmod +x src/index.mjs
+npm link
+```
+
+### CLI Commands
+
+```bash
+# Initialize social-light
+social-light init
+
+# Create a new post
+social-light create
+
+# List unpublished posts
+social-light list
+# List all posts (including published)
+social-light list --published
+
+# Edit a post by index
+social-light edit 1
+
+# Publish eligible posts
+social-light publish
+# Run in continuous mode (daemon)
+social-light publish --continuous
+
+# Clean published posts
+social-light clean
+# Clean all posts (including unpublished)
+social-light clean --unpublished
+
+# Start web interface
+social-light server
+# With custom port
+social-light server --port 8080
+
+# Remove social-light configuration
+social-light uninit
+```
+
+## Architecture
+
+### Core Components
+
+1. **CLI Commands** (`src/commands/`) - Implementations of CLI commands
+2. **Configuration** (`src/utils/config.mjs`) - Manages app configuration in `~/.social-light/config.json`
+3. **Database** (`src/utils/db.mjs`) - SQLite database operations using better-sqlite3 and Knex
+4. **Social Platform APIs** (`src/utils/social/`) - Interface with social media platforms
+5. **AI Utilities** (`src/utils/ai.mjs`) - OpenAI integration for content enhancement
+6. **Web Server** (`src/server/`) - Express server and client-side web interface
+
+### Data Flow
+
+1. User creates/edits posts via CLI or web interface
+2. Posts are stored in SQLite database with metadata
+3. AI enhances content when requested (via OpenAI)
+4. Scheduled posts are published to platforms (currently Bluesky)
+5. Post status is updated in database
+
+### Configuration
+
+Configuration is stored in `~/.social-light/config.json` and includes:
+- Database path
+- Platform credentials
+- AI settings (OpenAI API key)
+- Default platforms
+
+### Database
+
+SQLite database (`~/.social-light/social-light.db`) with tables for:
+- Posts (title, content, platforms, publish date, published status)
+- Activity logs
+
+## Technology Stack
+
+- Node.js (ES Modules)
+- SQLite via better-sqlite3
+- Express for web server
+- OpenAI API for AI features
+- Bluesky AT Protocol integration
+- Inquirer for CLI interaction
+
+## Development Notes
+
+- The application requires Node.js >= 20.9.0
+- ES Modules are used throughout the codebase (import/export syntax)
+- No formal testing framework is currently implemented
+- Configuration follows XDG standards for user data in home directory

package/README.md

@@ -4,6 +4,13 @@
 
 An AI-powered social media scheduling tool for Bluesky with CLI and web interface. More platforms coming soon!
 
+
+## Video overview
+
+<video src="https://github.com/user-attachments/assets/7ef8f61f-0421-41a9-8828-29ec44c2cc19
+"  style="height:480px" >
+
+
 ## Features
 
 - **CLI Interface**: Create, manage, and publish posts directly from your terminal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "social-light",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "AI-powered social media scheduling tool",
   "main": "src/index.mjs",
   "type": "module",

package/src/commands/create.mjs

@@ -129,14 +129,30 @@ export const createPost = async (argv) => {
     title = titleInput;
 
     // Generate publish date with AI or prompt for manual entry
-    spinner = ora("Suggesting publish date...").start();
-    let publishDate = "";
+    spinner = ora("Suggesting publish date and time...").start();
+    let publishDateTime = "";
 
     if (config.aiEnabled) {
-      publishDate = await suggestPublishDate();
-      spinner.succeed(`Suggested publish date: ${publishDate}`);
+      publishDateTime = await suggestPublishDate();
+      spinner.succeed(`Suggested publish date and time: ${publishDateTime}`);
     } else {
-      spinner.info("AI is disabled, skipping date suggestion");
+      spinner.info("AI is disabled, skipping date/time suggestion");
+      // Provide default as tomorrow at noon
+      const tomorrow = new Date();
+      tomorrow.setDate(tomorrow.getDate() + 1);
+      tomorrow.setHours(12, 0, 0, 0);
+      publishDateTime = `${tomorrow.toISOString().split('T')[0]} 12:00`;
+    }
+
+    // Parse suggested date/time
+    let suggestedDate = "";
+    let suggestedTime = "";
+    
+    if (publishDateTime.includes(" ")) {
+      [suggestedDate, suggestedTime] = publishDateTime.split(" ");
+    } else {
+      suggestedDate = publishDateTime;
+      suggestedTime = "12:00";
     }
 
     // Allow manual date override
@@ -146,7 +162,7 @@ export const createPost = async (argv) => {
         name: "dateInput",
         message:
           "Enter publish date (YYYY-MM-DD) or press Enter to use suggestion:",
-        default: publishDate,
+        default: suggestedDate,
         validate: (input) => {
           if (!input) return true;
           return /^\d{4}-\d{2}-\d{2}$/.test(input)
@@ -155,8 +171,68 @@ export const createPost = async (argv) => {
         },
       },
     ]);
-
-    publishDate = dateInput;
+    
+    // Allow manual time override with flexible input
+    const { timeInput } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "timeInput",
+        message:
+          "Enter publish time (HH:MM, H:MM, HH:MMam/pm or just 'Xpm') or press Enter to use suggestion:",
+        default: suggestedTime,
+        validate: (input) => {
+          if (!input) return true;
+          
+          // Support various formats
+          // 24-hour format: 13:45, 9:30
+          if (/^\d{1,2}:\d{2}$/.test(input)) return true;
+          
+          // 12-hour with am/pm: 1:45pm, 9:30am
+          if (/^\d{1,2}:\d{2}(am|pm)$/i.test(input)) return true;
+          
+          // Simple hour with am/pm: 3pm, 11am
+          if (/^\d{1,2}(am|pm)$/i.test(input)) return true;
+          
+          // Just hour: 13, 9 (assumes on the hour)
+          if (/^\d{1,2}$/.test(input)) return true;
+          
+          return "Please enter a valid time format";
+        },
+      },
+    ]);
+    
+    // Convert time input to standardized 24-hour format
+    let standardizedTime = timeInput;
+    
+    // Process different time formats
+    if (/^\d{1,2}(am|pm)$/i.test(timeInput)) {
+      // Format like "3pm"
+      const isPM = timeInput.toLowerCase().includes("pm");
+      let hour = parseInt(timeInput.replace(/[^0-9]/g, ""));
+      
+      if (isPM && hour < 12) hour += 12;
+      if (!isPM && hour === 12) hour = 0;
+      
+      standardizedTime = `${hour.toString().padStart(2, "0")}:00`;
+    } else if (/^\d{1,2}:\d{2}(am|pm)$/i.test(timeInput)) {
+      // Format like "3:30pm"
+      const isPM = timeInput.toLowerCase().includes("pm");
+      const timeParts = timeInput.replace(/[^0-9:]/g, "").split(":");
+      let hour = parseInt(timeParts[0]);
+      const minute = timeParts[1];
+      
+      if (isPM && hour < 12) hour += 12;
+      if (!isPM && hour === 12) hour = 0;
+      
+      standardizedTime = `${hour.toString().padStart(2, "0")}:${minute}`;
+    } else if (/^\d{1,2}$/.test(timeInput)) {
+      // Format like "15" (just hour)
+      const hour = parseInt(timeInput);
+      standardizedTime = `${hour.toString().padStart(2, "0")}:00`;
+    }
+    
+    // Combine date and time
+    publishDateTime = `${dateInput} ${standardizedTime}`;
 
     // Select platforms
     const { selectedPlatforms } = await inquirer.prompt([
@@ -229,7 +305,7 @@ export const createPost = async (argv) => {
       title,
       content,
       platforms,
-      publish_date: publishDate,
+      publish_date: publishDateTime,
     });
 
     // Log the action
@@ -237,7 +313,7 @@ export const createPost = async (argv) => {
       postId,
       title,
       platforms: selectedPlatforms,
-      publishDate,
+      publishDate: publishDateTime,
     });
 
     spinner.succeed(`Post created successfully with ID: ${postId}`);
@@ -249,8 +325,8 @@ export const createPost = async (argv) => {
       ` ${chalk.gray("•")} ${chalk.bold("Platforms:")} ${platforms || "None"}`
     );
     console.log(
-      ` ${chalk.gray("•")} ${chalk.bold("Publish Date:")} ${
-        publishDate || "Not scheduled"
+      ` ${chalk.gray("•")} ${chalk.bold("Publish Date & Time:")} ${
+        publishDateTime || "Not scheduled"
       }`
     );
     console.log(

package/src/commands/edit.mjs

@@ -125,13 +125,28 @@ export const editPost = async (argv) => {
       content = result.content;
     }
 
-    // Get publish date and platforms
-    const { publishDate, platforms } = await inquirer.prompt([
+    // Parse existing publish date and time
+    let existingDate = "";
+    let existingTime = "12:00";
+    
+    if (post.publish_date) {
+      if (post.publish_date.includes(" ")) {
+        [existingDate, existingTime] = post.publish_date.split(" ");
+      } else if (post.publish_date.includes("T")) {
+        [existingDate, existingTime] = post.publish_date.split("T");
+        existingTime = existingTime.substring(0, 5); // Get HH:MM part
+      } else {
+        existingDate = post.publish_date;
+      }
+    }
+    
+    // Get publish date and time
+    const { publishDate, publishTime, platforms } = await inquirer.prompt([
       {
         type: "input",
         name: "publishDate",
         message: "Edit publish date (YYYY-MM-DD):",
-        default: post.publish_date || "",
+        default: existingDate || "",
         validate: (input) => {
           if (!input) return true;
           return /^\d{4}-\d{2}-\d{2}$/.test(input)
@@ -139,6 +154,30 @@ export const editPost = async (argv) => {
             : "Please use YYYY-MM-DD format";
         },
       },
+      {
+        type: "input",
+        name: "publishTime",
+        message: "Edit publish time (HH:MM, H:MM, HH:MMam/pm or just 'Xpm'):",
+        default: existingTime || "12:00",
+        validate: (input) => {
+          if (!input) return true;
+          
+          // Support various formats
+          // 24-hour format: 13:45, 9:30
+          if (/^\d{1,2}:\d{2}$/.test(input)) return true;
+          
+          // 12-hour with am/pm: 1:45pm, 9:30am
+          if (/^\d{1,2}:\d{2}(am|pm)$/i.test(input)) return true;
+          
+          // Simple hour with am/pm: 3pm, 11am
+          if (/^\d{1,2}(am|pm)$/i.test(input)) return true;
+          
+          // Just hour: 13, 9 (assumes on the hour)
+          if (/^\d{1,2}$/.test(input)) return true;
+          
+          return "Please enter a valid time format";
+        },
+      },
       {
         type: "checkbox",
         name: "platforms",
@@ -158,13 +197,46 @@ export const editPost = async (argv) => {
     ]);
 
     const config = getConfig();
+    
+    // Format the time
+    let standardizedTime = publishTime;
+    
+    // Process different time formats
+    if (/^\d{1,2}(am|pm)$/i.test(publishTime)) {
+      // Format like "3pm"
+      const isPM = publishTime.toLowerCase().includes("pm");
+      let hour = parseInt(publishTime.replace(/[^0-9]/g, ""));
+      
+      if (isPM && hour < 12) hour += 12;
+      if (!isPM && hour === 12) hour = 0;
+      
+      standardizedTime = `${hour.toString().padStart(2, "0")}:00`;
+    } else if (/^\d{1,2}:\d{2}(am|pm)$/i.test(publishTime)) {
+      // Format like "3:30pm"
+      const isPM = publishTime.toLowerCase().includes("pm");
+      const timeParts = publishTime.replace(/[^0-9:]/g, "").split(":");
+      let hour = parseInt(timeParts[0]);
+      const minute = timeParts[1];
+      
+      if (isPM && hour < 12) hour += 12;
+      if (!isPM && hour === 12) hour = 0;
+      
+      standardizedTime = `${hour.toString().padStart(2, "0")}:${minute}`;
+    } else if (/^\d{1,2}$/.test(publishTime)) {
+      // Format like "15" (just hour)
+      const hour = parseInt(publishTime);
+      standardizedTime = `${hour.toString().padStart(2, "0")}:00`;
+    }
+    
+    // Combine date and time if date is provided
+    const fullPublishDate = publishDate ? `${publishDate} ${standardizedTime}` : "";
 
     // Update post in database
     const updatedPost = {
       title,
       content,
       platforms: platforms.join(","),
-      publish_date: publishDate,
+      publish_date: fullPublishDate,
     };
 
     const success = updatePost(post.id, updatedPost);

package/src/commands/publish.mjs

@@ -15,15 +15,21 @@ const isEligibleForPublishing = (post) => {
     return true;
   }
 
-  // Check if publish date is today or in the past
-  const publishDate = new Date(post.publish_date);
+  // Check if publish date and time is now or in the past
+  let publishDateTime;
+  
+  // If the date includes time component (contains 'T' or ' ')
+  if (post.publish_date.includes('T') || post.publish_date.includes(' ')) {
+    publishDateTime = new Date(post.publish_date);
+  } else {
+    // If only date is provided, assume start of day
+    publishDateTime = new Date(post.publish_date);
+    publishDateTime.setHours(0, 0, 0, 0);
+  }
+  
   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;
+  
+  return publishDateTime <= now;
 };
 
 /**

package/src/server/client/index.html

@@ -23,6 +23,23 @@
         --padding-card: 20px;
         --padding-section: 16px;
       }
+
+      /* Fix for calendar layout */
+      .calendar {
+        width: 100%;
+        overflow-x: hidden;
+      }
+      
+      /* Fix for time input to match other inputs */
+      input[type="time"] {
+        appearance: none;
+        -webkit-appearance: none;
+        padding: 8px 12px;
+        border-radius: var(--border-radius);
+        border: 1px solid var(--color-border);
+        background-color: var(--color-bg-dark);
+        color: var(--color-text-primary);
+      }
     </style>
   </head>
   <body>

package/src/server/client/main.mjs

@@ -215,6 +215,9 @@ const renderUnpublishedPosts = () => {
                 <button class="btn btn-sm btn-action" data-action="publish-post" data-post-id="${
                   post.id
                 }">Publish</button>
+                <button class="btn btn-sm btn-danger" data-action="delete-post" data-post-id="${
+                  post.id
+                }">Delete</button>
               </div>
             </div>
           </div>
@@ -250,6 +253,18 @@ const renderUnpublishedPosts = () => {
         await publishPost(postId);
       });
     });
+    
+  // Delete post buttons
+  mainContent
+    .querySelectorAll('[data-action="delete-post"]')
+    .forEach((button) => {
+      button.addEventListener("click", async () => {
+        if (confirm("Are you sure you want to delete this post? This action cannot be undone.")) {
+          const postId = parseInt(button.dataset.postId, 10);
+          await deletePost(postId);
+        }
+      });
+    });
 
   // Create post button
   mainContent
@@ -337,7 +352,7 @@ const renderPostEditor = () => {
 
   // Get selected platforms
   const selectedPlatforms = post.platforms
-    ? post.platforms.split(",").map((p) => p.trim())
+    ? post.platforms.split(",").map((p) => p.trim().toLowerCase())
     : [];
 
   mainContent.innerHTML = `
@@ -395,7 +410,7 @@ const renderPostEditor = () => {
               type="date" 
               id="post-date" 
               class="form-control" 
-              value="${post.publish_date || ""}"
+              value="${extractDatePart(post.publish_date) || ""}"
               placeholder="YYYY-MM-DD"
             >
             ${
@@ -408,11 +423,31 @@ const renderPostEditor = () => {
           </div>
         </div>
         
+        <div class="form-group">
+          <label class="form-label" for="post-time">Publish Time</label>
+          <div class="d-flex gap-sm">
+            <input 
+              type="time" 
+              id="post-time" 
+              class="form-control" 
+              value="${extractTimePart(post.publish_date) || "12:00"}"
+              placeholder="HH:MM"
+            >
+            ${
+              state.config.aiEnabled
+                ? `
+              <button type="button" class="btn" id="suggest-time-btn">Suggest with AI</button>
+            `
+                : ""
+            }
+          </div>
+        </div>
+        
         <div class="form-group">
           <label class="form-label">Platforms</label>
           <div class="d-flex gap-md flex-wrap">
-            ${platformOptions
-              .map(
+            ${platformOptions && platformOptions.length > 0 ? 
+              platformOptions.map(
                 (platform) => `
               <label class="d-flex align-center gap-sm">
                 <input 
@@ -424,8 +459,17 @@ const renderPostEditor = () => {
                 ${platform.name}
               </label>
             `
-              )
-              .join("")}
+              ).join("") : 
+              `<label class="d-flex align-center gap-sm">
+                <input 
+                  type="checkbox" 
+                  name="platforms" 
+                  value="bluesky"
+                  ${selectedPlatforms.includes("bluesky") || selectedPlatforms.includes("Bluesky") ? "checked" : ""}
+                >
+                Bluesky
+              </label>`
+            }
           </div>
         </div>
         
@@ -457,13 +501,21 @@ const renderPostEditor = () => {
       // Get form values
       const title = document.getElementById("post-title").value;
       const content = document.getElementById("post-content").value;
-      const publishDate = document.getElementById("post-date").value;
+      const date = document.getElementById("post-date").value;
+      const time = document.getElementById("post-time").value || "12:00";
+      const publishDate = date ? `${date} ${time}` : ""; // Combine date and time
       const platformElements = document.querySelectorAll(
         'input[name="platforms"]:checked'
       );
-      const platforms = Array.from(platformElements)
+      // Make sure we have at least one platform (Bluesky is default)
+      let platforms = Array.from(platformElements)
         .map((el) => el.value)
         .join(",");
+        
+      // If no platforms selected, default to Bluesky
+      if (!platforms) {
+        platforms = "bluesky";
+      }
 
       // Validate form
       if (!content) {
@@ -709,6 +761,10 @@ const renderPostEditor = () => {
 
         const result = await response.json();
         document.getElementById("post-date").value = result.date;
+        // Also update the time field if available
+        if (result.time) {
+          document.getElementById("post-time").value = result.time;
+        }
       } catch (error) {
         console.error("Error suggesting date:", error);
         alert(`Error: ${error.message}`);
@@ -718,6 +774,35 @@ const renderPostEditor = () => {
       }
     });
   }
+  
+  // Suggest time with AI (using same endpoint as date, but only updating time)
+  const suggestTimeBtn = document.getElementById("suggest-time-btn");
+  if (suggestTimeBtn) {
+    suggestTimeBtn.addEventListener("click", async () => {
+      try {
+        suggestTimeBtn.disabled = true;
+        suggestTimeBtn.textContent = "Generating...";
+
+        const response = await fetch("/api/ai/date");
+
+        if (!response.ok) {
+          const error = await response.json();
+          throw new Error(error.error || "Failed to suggest time");
+        }
+
+        const result = await response.json();
+        if (result.time) {
+          document.getElementById("post-time").value = result.time;
+        }
+      } catch (error) {
+        console.error("Error suggesting time:", error);
+        alert(`Error: ${error.message}`);
+      } finally {
+        suggestTimeBtn.disabled = false;
+        suggestTimeBtn.textContent = "Suggest with AI";
+      }
+    });
+  }
 };
 
 // Render calendar view
@@ -870,8 +955,16 @@ const publishPost = async (postId) => {
     });
 
     if (!response.ok) {
-      const error = await response.json();
-      throw new Error(error.error || "Failed to publish post");
+      const errorData = await response.json();
+      
+      // Special handling for scheduled posts
+      if (errorData.error === "Post is scheduled for future publication" && errorData.scheduledTime) {
+        const scheduledDate = new Date(errorData.scheduledTime);
+        const formattedDate = formatDate(scheduledDate);
+        throw new Error(`This post is scheduled for ${formattedDate}. It cannot be published before that time.`);
+      }
+      
+      throw new Error(errorData.error || "Failed to publish post");
     }
 
     const result = await response.json();
@@ -899,32 +992,138 @@ const publishPost = async (postId) => {
   }
 };
 
+// Delete a post
+const deletePost = async (postId) => {
+  try {
+    const button = document.querySelector(
+      `[data-action="delete-post"][data-post-id="${postId}"]`
+    );
+
+    if (button) {
+      button.disabled = true;
+      button.textContent = "Deleting...";
+    }
+
+    // Create a distinct request path to avoid conflicts
+    const response = await fetch(`/api/posts/${postId}/delete`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error || "Failed to delete post");
+    }
+
+    // Refresh posts
+    await fetchPosts();
+
+    // Update view
+    renderApp();
+
+    // Show success message
+    alert("Post deleted successfully!");
+  } catch (error) {
+    console.error("Error deleting post:", error);
+    alert(`Error: ${error.message}`);
+
+    // Re-enable button
+    const button = document.querySelector(
+      `[data-action="delete-post"][data-post-id="${postId}"]`
+    );
+    if (button) {
+      button.disabled = false;
+      button.textContent = "Delete";
+    }
+  }
+};
+
+// Helper function to extract date part from datetime string
+const extractDatePart = (dateTimeStr) => {
+  if (!dateTimeStr) return "";
+  
+  // Handle different formats
+  if (dateTimeStr.includes('T')) {
+    return dateTimeStr.split('T')[0];
+  } else if (dateTimeStr.includes(' ')) {
+    return dateTimeStr.split(' ')[0];
+  }
+  
+  // If only date is present
+  return dateTimeStr;
+};
+
+// Helper function to extract time part from datetime string
+const extractTimePart = (dateTimeStr) => {
+  if (!dateTimeStr) return "12:00";
+  
+  // Handle different formats
+  if (dateTimeStr.includes('T')) {
+    const timePart = dateTimeStr.split('T')[1];
+    return timePart ? timePart.substr(0, 5) : "12:00"; // Get HH:MM part
+  } else if (dateTimeStr.includes(' ')) {
+    return dateTimeStr.split(' ')[1] || "12:00";
+  }
+  
+  // If only date is present, return default time
+  return "12:00";
+};
+
 // Format date for display
-const formatDate = (dateStr) => {
-  if (!dateStr) return "No date set";
+const formatDate = (dateTimeStr) => {
+  if (!dateTimeStr) return "No date set";
 
-  const date = new Date(dateStr);
+  const date = new Date(dateTimeStr);
   const now = new Date();
   const tomorrow = new Date(now);
   tomorrow.setDate(tomorrow.getDate() + 1);
 
   // Check if date is today or tomorrow
   if (date.toDateString() === now.toDateString()) {
-    return "Today";
+    return `Today at ${formatTime(date)}`;
   } else if (date.toDateString() === tomorrow.toDateString()) {
-    return "Tomorrow";
+    return `Tomorrow at ${formatTime(date)}`;
   }
 
-  // Format as Month Day, Year
+  // Format as Month Day, Year at Time
   const options = { month: "short", day: "numeric", year: "numeric" };
-  return date.toLocaleDateString(undefined, options);
+  return `${date.toLocaleDateString(undefined, options)} at ${formatTime(date)}`;
+};
+
+// Format time for display
+const formatTime = (dateTimeStr) => {
+  if (!dateTimeStr) return "";
+  
+  // Handle date object or string
+  let date;
+  if (dateTimeStr instanceof Date) {
+    date = dateTimeStr;
+  } else {
+    date = new Date(dateTimeStr);
+  }
+  
+  // Use the Date object's built-in time formatting methods
+  // This handles timezone correctly
+  const hours = date.getHours();
+  const minutes = date.getMinutes().toString().padStart(2, '0');
+  const ampm = hours >= 12 ? 'PM' : 'AM';
+  const formattedHour = hours % 12 || 12; // Convert 0 to 12 for 12 AM
+  
+  return `${formattedHour}:${minutes} ${ampm}`;
 };
 
 // Format platforms for display
 const formatPlatforms = (platforms) => {
   if (!platforms) return "";
 
-  const platformsList = platforms.split(",").map((p) => p.trim());
+  // Handle empty string but not null/undefined
+  if (platforms === "") return "";
+
+  // Make sure we have a string and filter out empty values
+  const platformsStr = String(platforms);
+  const platformsList = platformsStr.split(",").map((p) => p.trim()).filter(p => p);
 
   return platformsList
     .map((platform) => {

package/src/server/client/styles.css

@@ -125,6 +125,18 @@ p {
   color: white;
 }
 
+.btn-sm.btn-danger {
+  font-size: 12px;
+  padding: 4px 8px;
+  border-color: var(--color-accent-danger);
+  color: var(--color-accent-danger);
+}
+
+.btn-sm.btn-danger:hover {
+  background-color: var(--color-accent-danger);
+  color: white;
+}
+
 .btn-sm {
   padding: 4px 8px;
   font-size: 12px;
@@ -304,6 +316,8 @@ textarea.form-control {
   display: grid;
   grid-template-columns: repeat(7, 1fr);
   gap: 8px;
+  width: 100%;
+  overflow-x: hidden;
 }
 
 .calendar-day {
@@ -312,17 +326,25 @@ textarea.form-control {
   border-radius: var(--border-radius);
   border: 1px solid var(--color-border);
   background-color: var(--color-bg-card);
+  min-width: 0; /* Prevent overflow */
+  width: 100%;
+  max-width: 100%;
 }
 
 .calendar-day-header {
   text-align: center;
   font-weight: 600;
   margin-bottom: 8px;
+  min-width: 0; /* Prevent overflow */
+  width: 100%;
+  max-width: 100%;
 }
 
 .calendar-day-content {
   font-size: 12px;
   overflow: hidden;
+  min-width: 0; /* Prevent overflow */
+  width: 100%;
 }
 
 .calendar-day-post {
@@ -333,6 +355,7 @@ textarea.form-control {
   white-space: nowrap;
   overflow: hidden;
   text-overflow: ellipsis;
+  max-width: 100%;
 }
 
 /* Loading */

package/src/server/index.mjs

@@ -11,6 +11,7 @@ import {
   updatePost,
   markAsPublished,
   logAction,
+  deletePost,
 } from "../utils/db.mjs";
 import { getSocialAPI } from "../utils/social/index.mjs";
 import {
@@ -100,6 +101,7 @@ const setupApiRoutes = (app) => {
         "/api/posts",
         "/api/posts/:id",
         "/api/publish/:id",
+        "/api/posts/:id/delete",
         "/api/ai/title",
         "/api/ai/date",
         "/api/ai/enhance",
@@ -115,10 +117,11 @@ const setupApiRoutes = (app) => {
     // Remove sensitive information
     const safeConfig = {
       ...config,
-      // Add default platforms for client
+      // Always ensure platforms are available
       platforms: [
-        // { id: 'twitter', name: 'Twitter', icon: 'twitter' },
         { id: "bluesky", name: "Bluesky", icon: "cloud" },
+        // Add more platforms here when they become available
+        // { id: 'twitter', name: 'Twitter', icon: 'twitter' },
         // { id: 'tiktok', name: 'TikTok', icon: 'music' }
       ],
     };
@@ -155,17 +158,23 @@ const setupApiRoutes = (app) => {
   // Create new post
   app.post("/api/posts", async (req, res) => {
     try {
-      const { title, content, platforms, publish_date } = req.body;
+      const { title, content, platforms, publish_date, publish_time } = req.body;
 
       if (!content) {
         return res.status(400).json({ error: "Content is required" });
       }
 
+      // Combine date and time if both are provided
+      let dateTimeValue = publish_date;
+      if (publish_date && publish_time) {
+        dateTimeValue = `${publish_date} ${publish_time}`;
+      }
+
       const postId = createPost({
         title,
         content,
         platforms: Array.isArray(platforms) ? platforms.join(",") : platforms,
-        publish_date,
+        publish_date: dateTimeValue,
       });
 
       logAction("post_created", { postId, source: "web" });
@@ -180,7 +189,7 @@ const setupApiRoutes = (app) => {
   app.put("/api/posts/:id", async (req, res) => {
     try {
       const id = parseInt(req.params.id, 10);
-      const { title, content, platforms, publish_date } = req.body;
+      const { title, content, platforms, publish_date, publish_time } = req.body;
 
       const post = getPostById(id);
 
@@ -188,11 +197,17 @@ const setupApiRoutes = (app) => {
         return res.status(404).json({ error: "Post not found" });
       }
 
+      // Combine date and time if both are provided
+      let dateTimeValue = publish_date;
+      if (publish_date && publish_time) {
+        dateTimeValue = `${publish_date} ${publish_time}`;
+      }
+
       const success = updatePost(id, {
         title,
         content,
         platforms: Array.isArray(platforms) ? platforms.join(",") : platforms,
-        publish_date,
+        publish_date: dateTimeValue,
       });
 
       if (!success) {
@@ -207,6 +222,28 @@ const setupApiRoutes = (app) => {
     }
   });
 
+  // Delete post - using a different route pattern to avoid conflicts
+  app.post("/api/posts/:id/delete", async (req, res) => {
+    try {
+      const id = parseInt(req.params.id, 10);
+      const post = getPostById(id);
+
+      if (!post) {
+        return res.status(404).json({ error: "Post not found" });
+      }
+
+      const success = deletePost(id);
+
+      if (success) {
+        res.json({ success: true });
+      } else {
+        res.status(500).json({ error: "Failed to delete post" });
+      }
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
   // Publish post
   app.post("/api/publish/:id", async (req, res) => {
     try {
@@ -226,6 +263,29 @@ const setupApiRoutes = (app) => {
           .status(400)
           .json({ error: "No platforms specified for post" });
       }
+      
+      // Check if post is eligible for publishing based on date/time
+      if (post.publish_date) {
+        let publishDateTime;
+        
+        // If the date includes time component (contains 'T' or ' ')
+        if (post.publish_date.includes('T') || post.publish_date.includes(' ')) {
+          publishDateTime = new Date(post.publish_date);
+        } else {
+          // If only date is provided, assume start of day
+          publishDateTime = new Date(post.publish_date);
+          publishDateTime.setHours(0, 0, 0, 0);
+        }
+        
+        const now = new Date();
+        
+        if (publishDateTime > now) {
+          return res.status(400).json({ 
+            error: "Post is scheduled for future publication",
+            scheduledTime: publishDateTime.toISOString()
+          });
+        }
+      }
 
       // Initialize social API
       const socialAPI = getSocialAPI();
@@ -283,11 +343,21 @@ const setupApiRoutes = (app) => {
     }
   });
 
-  // Suggest publish date with AI
+  // Suggest publish date and time with AI
   app.get("/api/ai/date", async (req, res) => {
     try {
-      const date = await suggestPublishDate();
-      res.json({ date });
+      const dateTime = await suggestPublishDate();
+      
+      // Parse datetime to separate date and time if needed for client
+      let date, time;
+      if (dateTime.includes(" ")) {
+        [date, time] = dateTime.split(" ");
+      } else {
+        date = dateTime;
+        time = "12:00"; // Default time
+      }
+      
+      res.json({ dateTime, date, time });
     } catch (error) {
       res.status(500).json({ error: error.message });
     }

package/src/utils/ai.mjs

@@ -78,10 +78,10 @@ export const generateTitle = async (content) => {
 };
 
 /**
- * Suggest a publish date for a post using AI
- * @returns {string} Suggested publish date in YYYY-MM-DD format
+ * Suggest a publish date and time for a post using AI
+ * @returns {string} Suggested publish date and time in YYYY-MM-DD HH:MM format
  * @example
- * const date = await suggestPublishDate();
+ * const dateTime = await suggestPublishDate();
  */
 export const suggestPublishDate = async () => {
   const openai = getOpenAIClient();
@@ -94,10 +94,11 @@ export const suggestPublishDate = async () => {
     const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='posts';").get();
     
     if (!tableExists) {
-      // If table doesn't exist, just return tomorrow's date
+      // If table doesn't exist, just return tomorrow's date at noon
       const tomorrow = new Date();
       tomorrow.setDate(tomorrow.getDate() + 1);
-      return tomorrow.toISOString().split('T')[0];
+      tomorrow.setHours(12, 0, 0, 0);
+      return `${tomorrow.toISOString().split('T')[0]} 12:00`;
     }
     
     // Get historical posts for analysis if table exists
@@ -108,14 +109,15 @@ export const suggestPublishDate = async () => {
       // Fallback to simple date suggestion if AI is disabled or not enough data
       const tomorrow = new Date(today);
       tomorrow.setDate(tomorrow.getDate() + 1);
-      return tomorrow.toISOString().split('T')[0];
+      tomorrow.setHours(12, 0, 0, 0);
+      return `${tomorrow.toISOString().split('T')[0]} 12:00`;
     }
     
     // Format post history for the AI
     const postHistory = posts
       .filter(post => post.publish_date)
       .map(post => ({
-        date: post.publish_date,
+        dateTime: post.publish_date,
         platform: post.platforms
       }));
     
@@ -124,33 +126,40 @@ export const suggestPublishDate = async () => {
       messages: [
         {
           role: 'system',
-          content: 'You are a social media scheduling assistant. Based on the user\'s posting history, suggest an optimal date for their next post. Consider post frequency, patterns, and optimal timing. Return only the date in YYYY-MM-DD format.'
+          content: 'You are a social media scheduling assistant. Based on the user\'s posting history, suggest an optimal date and time for their next post. Consider post frequency, patterns, and optimal timing for engagement. Return the date and time in YYYY-MM-DD HH:MM format using 24-hour time.'
         },
         {
           role: 'user',
-          content: `Here is my posting history: ${JSON.stringify(postHistory)}. Today is ${today.toISOString().split('T')[0]}. When should I schedule my next post?`
+          content: `Here is my posting history: ${JSON.stringify(postHistory)}. Today is ${today.toISOString().split('T')[0]} ${today.getHours()}:${today.getMinutes().toString().padStart(2, '0')}. When should I schedule my next post?`
         }
       ],
-      max_tokens: 20
+      max_tokens: 30
     });
     
-    const suggestedDate = response.choices[0].message.content.trim();
+    const suggestedDateTime = response.choices[0].message.content.trim();
     
-    // Validate date format
-    if (/^\d{4}-\d{2}-\d{2}$/.test(suggestedDate)) {
-      return suggestedDate;
+    // Validate date and time format
+    if (/^\d{4}-\d{2}-\d{2} \d{1,2}:\d{2}$/.test(suggestedDateTime)) {
+      return suggestedDateTime;
     }
     
-    // Extract date if the AI included other text
-    const dateMatch = suggestedDate.match(/\d{4}-\d{2}-\d{2}/);
+    // Extract date and time if the AI included other text
+    const dateTimeMatch = suggestedDateTime.match(/(\d{4}-\d{2}-\d{2}) (\d{1,2}:\d{2})/);
+    if (dateTimeMatch) {
+      return `${dateTimeMatch[1]} ${dateTimeMatch[2]}`;
+    }
+    
+    // Try to extract just the date if time format fails
+    const dateMatch = suggestedDateTime.match(/\d{4}-\d{2}-\d{2}/);
     if (dateMatch) {
-      return dateMatch[0];
+      return `${dateMatch[0]} 12:00`;
     }
     
     // Fallback
     const tomorrow = new Date(today);
     tomorrow.setDate(tomorrow.getDate() + 1);
-    return tomorrow.toISOString().split('T')[0];
+    tomorrow.setHours(12, 0, 0, 0);
+    return `${tomorrow.toISOString().split('T')[0]} 12:00`;
   } catch (error) {
     console.error('Error suggesting publish date:', error.message);
     
@@ -158,7 +167,8 @@ export const suggestPublishDate = async () => {
     const today = new Date();
     const tomorrow = new Date(today);
     tomorrow.setDate(tomorrow.getDate() + 1);
-    return tomorrow.toISOString().split('T')[0];
+    tomorrow.setHours(12, 0, 0, 0);
+    return `${tomorrow.toISOString().split('T')[0]} 12:00`;
   }
 };
 

package/src/utils/db.mjs

@@ -90,6 +90,7 @@ export const initializeDb = (existingDb = null) => {
         content TEXT NOT NULL,
         platforms TEXT,
         publish_date TEXT,
+        publish_time TEXT,
         published INTEGER DEFAULT 0,
         created_at TEXT DEFAULT CURRENT_TIMESTAMP,
         updated_at TEXT DEFAULT CURRENT_TIMESTAMP
@@ -316,3 +317,39 @@ export const deletePosts = (options = { published: true }) => {
     throw error;
   }
 };
+
+/**
+ * Delete a single post by ID
+ * @param {number} id - Post ID
+ * @returns {boolean} True if successful
+ * @example
+ * const success = deletePost(1);
+ */
+export const deletePost = (id) => {
+  const db = getDb();
+  
+  try {
+    // Get post to determine if it was published (for logging)
+    const post = getPostById(id);
+    if (!post) return false;
+    
+    // Delete the post
+    const result = db.prepare('DELETE FROM posts WHERE id = ?').run(id);
+    
+    if (result.changes > 0) {
+      // Log the action
+      logAction('post_deleted', { 
+        postId: id,
+        wasPublished: post.published === 1,
+        title: post.title
+      });
+      
+      return true;
+    }
+    
+    return false;
+  } catch (error) {
+    console.error('Error deleting post:', error.message);
+    return false;
+  }
+};