AI-Driven Development: Modernizing a Decade-Old Website in 3 Days

36 collapsed lines
1
import fs from 'fs/promises' // Use promises API for async operations
2
import path from 'path'
3
import { exit } from 'process' // Explicit import for exit
4

5
import matter from 'gray-matter' // Re-import gray-matter
6

7
/**
8
 * Defines the structure for the front matter of a blog post.
9
 */
10
interface FrontMatter {
11
  title: string
12
  description: string
13
  pubDate: string // ISO 8601 date string
14
  heroImage: string
15
}
16

17
/**
18
 * Generates a URL-friendly slug from a given text string.
19
 * Converts to lowercase, replaces spaces with hyphens, removes non-alphanumeric characters (except hyphens),
20
 * and trims leading/trailing hyphens.
21
 *
22
 * @param text - The input string to slugify.
23
 * @returns The generated slug string.
24
 */
25
function slugify(text: string): string {
26
  return text
27
    .toString() // Ensure input is a string
28
    .toLowerCase()
29
    .trim()
30
    .replace(/\s+/g, '-') // Replace spaces and consecutive whitespace with a single hyphen
31
    .replace(/[^\w-]+/g, '') // Remove characters that are not word characters, digits, or hyphens
32
    .replace(/--+/g, '-') // Collapse multiple consecutive hyphens into one
33
    .replace(/^-+/, '') // Remove hyphens from the start
34
    .replace(/-+$/, '') // Remove hyphens from the end
35
}
36

37
/**
38
 * Creates a new markdown file for a blog post with predefined front matter.
39
 *
40
 * @param title - The title of the new blog post, provided as a command-line argument.
41
 */
42
async function createNewPost(title: string): Promise<void> {
43
  const slug = slugify(title)
44
  const filename = `${slug}.md`
45
  const targetDir = path.join('src', 'content', 'post')
46
  const filePath = path.join(targetDir, filename)
47

48
  // Prepare front matter data
49
  const frontMatterData: FrontMatter = {
50
    title: title, // Let gray-matter handle quoting
51
    description: '# Add a brief description here',
52
    pubDate: new Date().toISOString(),
53
    heroImage: `# Add path to hero image, e.g., /images/posts/${slug}/hero.jpg`,
54
  }
55

56
  // Define the initial content body
57
  const mainContent = 'Write your post content here...'
58

59
  // Combine front matter and content using gray-matter
60
  const fileContent = matter.stringify(mainContent, frontMatterData) // Use default stringify
61

62
  try {
63
    // Ensure the target directory exists before writing the file
64
    await fs.mkdir(targetDir, { recursive: true })
65

66
    // Write the file, using 'wx' flag to prevent overwriting existing files
67
    await fs.writeFile(filePath, fileContent, { flag: 'wx' })
68
    console.log(`✅ Created new post: ${filePath}`)
28 collapsed lines
69
  } catch (error) {
70
    // Type guard to check if the error is a Node.js file system error
71
    if (error instanceof Error && 'code' in error) {
72
      if (error.code === 'EEXIST') {
73
        console.error(`❌ Error: File already exists at ${filePath}`)
74
      } else {
75
        console.error(`❌ Error creating file: ${error.message} (Code: ${error.code})`)
76
      }
77
    } else {
78
      // Handle unexpected error types
79
      console.error('❌ An unexpected error occurred:', error)
80
    }
81
    exit(1) // Exit with error code
82
  }
83
}
84

85
// --- Script Execution ---
86

87
// Get the post title from command line arguments
88
const postTitle = process.argv[2]
89

90
// Validate input
91
if (!postTitle) {
92
  console.error('❌ Error: Please provide a post title as the first argument.')
93
  console.log('Usage: pnpm new-post "Your Post Title"')
94
  exit(1) // Exit with error code
95
}
96

97
// Run the main function
98
createNewPost(postTitle).catch((err) => {
99
  // Catch any unhandled promise rejections from createNewPost
100
  console.error('❌ An unexpected error occurred during script execution:', err)
101
  exit(1)
102
})

179 collapsed lines
1
/* eslint-disable no-console */ // Allow console logs for CLI script feedback
2

3
import * as fs from 'fs/promises'
4
import * as path from 'path'
5

6
import { PredictionServiceClient, helpers } from '@google-cloud/aiplatform'
7
import { status as GrpcStatus } from '@grpc/grpc-js' // Rename for clarity
8
import dotenv from 'dotenv'
9
import matter from 'gray-matter' // Used for frontmatter parsing
10

11
import type { protos } from '@google-cloud/aiplatform'
12

13
// --- Type Aliases & Interfaces ---
14

15
// Specific protos types for request/response clarity
16
type IPredictRequest = protos.google.cloud.aiplatform.v1.IPredictRequest
17
type IPredictResponse = protos.google.cloud.aiplatform.v1.IPredictResponse
18

19
/** Defines the structure for script configuration settings. */
20
interface ScriptConfig {
21
  readonly postsDir: string
22
  readonly imageOutputDirRoot: string
23
  readonly imagePublicPathRoot: string
24
  readonly googleProjectId: string
25
  readonly googleLocation: string
26
  readonly googleAiModel: string
27
  readonly heroImageFilename: string
28
  readonly defaultAspectRatio: string
29
}
30

31
/** Defines the structure for parsed command-line arguments. */
32
interface CliArguments {
33
  readonly postSlug: string
34
  readonly userPrompt: string
35
}
36

37
/** Represents the result of parsing a Markdown file with frontmatter. */
38
type ParsedPost = matter.GrayMatterFile<string>
39

40
// --- Constants ---
41
const DEFAULT_GOOGLE_LOCATION = 'us-central1'
42
const DEFAULT_HERO_FILENAME = 'hero.jpg'
43
const DEFAULT_ASPECT_RATIO = '16:9'
44
const GOOGLE_AI_MODEL = 'imagegeneration@006' // Imagen model identifier
45

46
const ADC_ERROR_MESSAGE = 'Could not load the default credentials'
47
const ADC_HELP_MESSAGE = `
48
❌ Authentication Error: Ensure Application Default Credentials (ADC) are valid.
49
   Run: gcloud auth application-default login
50
`
51

52
// --- Configuration Loading & Validation ---
53

54
/**
55
 * Loads configuration from environment variables and defaults.
56
 * @returns The script configuration object.
57
 * @throws {Error} If essential configuration (GOOGLE_PROJECT_ID) is missing.
58
 */
59
function loadConfig(): ScriptConfig {
60
  dotenv.config() // Load .env file
61

62
  const googleProjectId = process.env.GOOGLE_PROJECT_ID
63
  if (!googleProjectId) {
64
    console.error(
65
      'Error: GOOGLE_PROJECT_ID environment variable is not set.',
66
      'Please ensure it is defined in your .env file or environment.',
67
    )
68
    process.exit(1) // Exit early if critical config is missing
69
  }
70

71
  return Object.freeze({
72
    // Make config immutable
73
    postsDir: path.resolve(process.cwd(), 'src/content/post'),
74
    imageOutputDirRoot: path.resolve(process.cwd(), 'public/images/posts'),
75
    imagePublicPathRoot: '/images/posts',
76
    googleProjectId,
77
    googleLocation: process.env.GOOGLE_LOCATION || DEFAULT_GOOGLE_LOCATION,
78
    googleAiModel: GOOGLE_AI_MODEL,
79
    heroImageFilename: DEFAULT_HERO_FILENAME,
80
    defaultAspectRatio: DEFAULT_ASPECT_RATIO,
81
  })
82
}
83

84
// --- Utility Functions ---
85

86
/**
87
 * Checks if a file exists at the given path.
88
 * @param filePath - The path to the file.
89
 * @returns True if the file exists, false otherwise.
90
 */
91
async function fileExists(filePath: string): Promise<boolean> {
92
  try {
93
    await fs.access(filePath)
94
    return true
95
  } catch {
96
    return false
97
  }
98
}
99

100
/**
101
 * Parses command-line arguments for post slug and prompt.
102
 * Exits the process with an error message if arguments are invalid.
103
 * @returns An object containing the postSlug and userPrompt.
104
 */
105
function parseArguments(): CliArguments {
106
  const args = process.argv.slice(2) // Skip node executable and script path
107

108
  if (args.length !== 2 || !args[0]?.trim() || !args[1]?.trim()) {
109
    console.error('Usage: pnpm run generate-hero-image <post-slug> "<prompt>"')
110
    console.error('Example: pnpm run generate-hero-image my-new-post "A futuristic cityscape"')
111
    process.exit(1)
112
  }
113

114
  return Object.freeze({
115
    // Make args immutable
116
    postSlug: args[0],
117
    userPrompt: args[1],
118
  })
119
}
120

121
/**
122
 * Handles common script errors, logs informative messages, and exits.
123
 * @param error - The error object or message.
124
 * @param context - Optional context message (e.g., "while generating image").
125
 */
126
function handleError(error: unknown, context?: string): never {
127
  // 'never' indicates function exits
128
  console.error(`\n❌ An error occurred${context ? ` ${context}` : ''}:`)
129

130
  if (error instanceof Error) {
131
    console.error(`   Message: ${error.message}`)
132
    // Check for specific known error types or messages
133
    if (error.message.includes(ADC_ERROR_MESSAGE)) {
134
      console.error(ADC_HELP_MESSAGE)
135
    } else {
136
      // Check for gRPC status codes if available (often indicates API issues)
137
      const grpcError = error as any // Use 'any' cautiously for type casting
138
      if (grpcError && typeof grpcError.code === 'number') {
139
        console.error(`   gRPC Code: ${grpcError.code} (${GrpcStatus[grpcError.code] || 'Unknown'})`)
140
        if (grpcError.details) console.error(`   Details: ${grpcError.details}`)
141
        if (grpcError.code === GrpcStatus.UNAUTHENTICATED || grpcError.code === GrpcStatus.PERMISSION_DENIED) {
142
          console.error(ADC_HELP_MESSAGE)
143
        }
144
      } else if (error.stack) {
145
        // Provide stack trace for other errors if available
146
        console.error(`   Stack: ${error.stack}`)
147
      }
148
    }
149
  } else {
150
    // Handle non-Error types
151
    console.error('   Error details:', error)
152
  }
153

154
  process.exit(1)
155
}
156

157
// --- Core Logic Functions ---
158

159
/**
160
 * Reads a post file and parses its frontmatter.
161
 * @param postFilePath - Path to the markdown post file.
162
 * @returns The parsed GrayMatterFile object.
163
 * @throws {Error} If the file doesn't exist or cannot be parsed.
164
 */
165
async function readAndParsePost(postFilePath: string): Promise<ParsedPost> {
166
  if (!(await fileExists(postFilePath))) {
167
    throw new Error(`Post file not found at ${postFilePath}`)
168
  }
169

170
  try {
171
    const postFileContent = await fs.readFile(postFilePath, 'utf-8')
172
    return matter(postFileContent)
173
  } catch (error) {
174
    throw new Error(
175
      `Failed to read or parse post file ${postFilePath}: ${error instanceof Error ? error.message : String(error)}`,
176
    )
177
  }
178
}
179

180
/**
181
 * Builds the prediction request object for the Google AI Platform.
182
 * @param prompt - The text prompt for image generation.
183
 * @param config - The script configuration.
184
 * @returns The constructed IPredictRequest object.
185
 * @throws {Error} If prompt or parameters cannot be converted.
186
 */
187
function buildPredictRequest(prompt: string, config: ScriptConfig): IPredictRequest {
188
  const endpoint = `projects/${config.googleProjectId}/locations/${config.googleLocation}/publishers/google/models/${config.googleAiModel}`
189

190
  const instanceValue = helpers.toValue({ prompt })
191
  if (!instanceValue) {
192
    throw new Error('Failed to convert prompt instance to IValue')
193
  }
194

195
  const parametersObj = {
196
    sampleCount: 1,
197
    aspectRatio: config.defaultAspectRatio,
198
    // Add other parameters like negativePrompt, seed, etc., here if needed
199
  }
200
  const parametersValue = helpers.toValue(parametersObj)
201
  if (!parametersValue) {
202
    throw new Error('Failed to convert parameters object to IValue')
203
  }
204

205
  return {
206
    endpoint,
207
    instances: [instanceValue],
208
    parameters: parametersValue,
209
  }
210
}
211

212
/**
213
 * Calls the Google AI Platform Prediction Service.
214
 * @param request - The prediction request object.
215
 * @param modelName - The name of the AI model being used (for logging).
216
 * @returns The prediction response object.
217
 * @throws {Error} If the API call fails.
218
 */
219
async function callPredictionService(request: IPredictRequest, modelName: string): Promise<IPredictResponse> {
220
  console.log(`\nSending request to AI Platform Prediction Service (Model: ${modelName})...`)
221
  // Instantiate the client just before the call
222
  const predictionServiceClient = new PredictionServiceClient()
223

224
  // The predict method returns a tuple: [response, request, options]
225
  const [response] = await predictionServiceClient.predict(request)
226

227
  if (!response) {
228
    // This case should ideally be handled by the SDK throwing an error,
229
    // but adding a check for robustness.
230
    throw new Error('Received undefined response from AI Platform predict call.')
231
  }
232
  console.log('Received response from AI Platform.')
233
  return response
234
}
124 collapsed lines
235

236
/**
237
 * Extracts the base64 encoded image data from the prediction response.
238
 * @param response - The prediction response object.
239
 * @returns Base64 encoded string of the generated image.
240
 * @throws {Error} If the response structure is unexpected or lacks image data.
241
 */
242
function extractImageData(response: IPredictResponse): string {
243
  // Safely access the prediction data using optional chaining
244
  const imageBase64 = response.predictions?.[0]?.structValue?.fields?.bytesBase64Encoded?.stringValue
245

246
  if (!imageBase64) {
247
    console.error('Unexpected response structure:', JSON.stringify(response, null, 2))
248
    throw new Error('No valid base64 image data found in the AI Platform response.')
249
  }
250

251
  console.log('Image data extracted successfully.')
252
  return imageBase64
253
}
254

255
/**
256
 * Generates an image using the Google AI Platform Prediction Service.
257
 * Orchestrates request building, API call, and response parsing.
258
 * @param prompt - The text prompt for image generation.
259
 * @param config - The script configuration.
260
 * @returns Base64 encoded string of the generated image.
261
 */
262
async function generateImage(prompt: string, config: ScriptConfig): Promise<string> {
263
  try {
264
    const request = buildPredictRequest(prompt, config)
265
    const response = await callPredictionService(request, config.googleAiModel)
266
    const imageBase64 = extractImageData(response)
267
    return imageBase64
268
  } catch (error) {
269
    // Use the centralized error handler
270
    handleError(error, 'while generating image')
271
  }
272
}
273

274
/**
275
 * Saves the generated image to the specified path.
276
 * Creates the output directory if it doesn't exist.
277
 * @param imageBase64 - Base64 encoded image data.
278
 * @param outputPath - The full path where the image should be saved.
279
 * @param outputDir - The directory where the image will be saved.
280
 */
281
async function saveImage(imageBase64: string, outputPath: string, outputDir: string): Promise<void> {
282
  try {
283
    await fs.mkdir(outputDir, { recursive: true })
284
    await fs.writeFile(outputPath, imageBase64, 'base64')
285
    console.log(`Image saved to: ${outputPath}`)
286
  } catch (error) {
287
    // Use the centralized error handler for saving errors
288
    handleError(error, `while saving image to ${outputPath}`)
289
  }
290
}
291

292
/**
293
 * Updates the post's frontmatter with the new hero image path.
294
 * @param postFilePath - Path to the markdown post file.
295
 * @param parsedPost - The parsed frontmatter and content.
296
 * @param imagePublicPath - The public URL path for the hero image.
297
 */
298
async function updateFrontmatter(postFilePath: string, parsedPost: ParsedPost, imagePublicPath: string): Promise<void> {
299
  try {
300
    // Create a mutable copy of data for modification
301
    const updatedData = { ...parsedPost.data, heroImage: imagePublicPath }
302
    const updatedPostFileContent = matter.stringify(parsedPost.content, updatedData)
303
    await fs.writeFile(postFilePath, updatedPostFileContent, 'utf-8')
304
    console.log(`Updated frontmatter in: ${postFilePath}`)
305
  } catch (error) {
306
    // Log a warning instead of exiting, as the image was generated.
307
    console.warn(`\n⚠️ Warning: Failed to update frontmatter for ${postFilePath}.`)
308
    console.warn(`   Error: ${error instanceof Error ? error.message : String(error)}`)
309
    console.warn('   The image was generated and saved, but the post file needs manual updating.')
310
  }
311
}
312

313
// --- Main Execution ---
314

315
/**
316
 * Main function to orchestrate the hero image generation process.
317
 */
318
async function main() {
319
  const config = loadConfig() // Load and validate config first
320
  const { postSlug, userPrompt } = parseArguments()
321

322
  console.log(`Generating hero image for post: ${postSlug}`)
323
  console.log(`User prompt: "${userPrompt}"`)
324

325
  // Construct paths using the validated config
326
  const postFilePath = path.join(config.postsDir, `${postSlug}.md`)
327
  const imageOutputDir = path.join(config.imageOutputDirRoot, postSlug)
328
  const imageOutputPath = path.join(imageOutputDir, config.heroImageFilename)
329
  // Ensure consistent path separators for URLs
330
  const imagePublicPath = [config.imagePublicPathRoot, postSlug, config.heroImageFilename]
331
    .join('/')
332
    .replace(/\/+/g, '/') // Normalize slashes
333

334
  // 1. Read and parse the post file
335
  const parsedPost = await readAndParsePost(postFilePath).catch((error) =>
336
    handleError(error, 'while reading post file'),
337
  )
338

339
  // Note: Add logic here if you want to enhance the prompt with post data
340
  const fullPrompt = userPrompt // Keep it simple for now
341

342
  // 2. Generate the image via AI Platform
343
  const imageBase64 = await generateImage(fullPrompt, config) // Error handled within generateImage
344

345
  // 3. Save the generated image
346
  await saveImage(imageBase64, imageOutputPath, imageOutputDir) // Error handled within saveImage
347

348
  // 4. Update the post's frontmatter
349
  await updateFrontmatter(postFilePath, parsedPost, imagePublicPath) // Logs warning on failure
350

351
  console.log(`\n✅ Successfully generated and linked hero image: ${imagePublicPath}`)
352
}
353

354
// --- Script Entry Point ---
355
main().catch((error) => {
356
  // Catch any unexpected errors not handled by specific try/catch blocks or handleError
357
  handleError(error, 'during script execution')
358
})