投稿のひな型を生成するスクリプトを新しくした

Geminiを利用して投稿のタグやスラッグを自動生成し、ファイルが作成されたら現在開いているエディタで自動的に開かれるようにした。

Geminiによるスラッグとタグの生成#

Geminiを利用してスラッグとタグを生成する関数を作成した。

Gemini APIではgenerationConfigにresponseMineTypeやresponseSchemaを指定することで、生成されるデータの形式を指定できる。

1
async function generateMetadataWithGemini(title) {
2
  const API_URL = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-05-20:generateContent?key=${GEMINI_API_KEY}`;
3

4
  const payload = {
5
    contents: [{
6
      parts: [{
7
        text: `Based on the following blog post title, please generate a URL-friendly English slug and an array of relevant tags. The tags should only include the names of any libraries or services that are likely to be mentioned. \ntitle: "${title}"`
8
      }]
9
    }],
10
    // @see https://cloud.google.com/vertex-ai/generative-ai/docs/reference/rest/v1/GenerationConfig
11
    generationConfig: {
12
      responseMimeType: "application/json",
13
      responseSchema: {
14
        type: "OBJECT",
15
        properties: {
16
          slug: {
17
            type: "STRING",
18
            description: "URL-friendly slug in English, using hyphens as separators."
19
          },
20
          tags: {
21
            type: "ARRAY",
22
            items: {
23
              type: "STRING"
24
            },
25
            description: "An array of relevant tags for the blog post, focusing on library and service names."
26
          }
27
        },
28
        required: ["slug", "tags"]
29
      }
30
    }
31
  };
32

33
    const response = await fetch(API_URL, {
34
        method: 'POST',
35
        headers: {
36
        'Content-Type': 'application/json',
37
        },
38
        body: JSON.stringify(payload),
39
    });
40

41
    if (!response.ok) {
42
        const errorBody = await response.text();
43
        throw new Error(`API request failed with status ${response.status}: ${errorBody}`);
44
    }
45

46
    const result = await response.json();
47

48
    return JSON.parse(result.candidates[0].content.parts[0].text);
49
}

エディタの特定#

ひな型が作成されたら自動的にファイルが開かれてほしいが、エディタとしてVSCodeとCursorを気分で使い分けているためエディタを特定する必要がある。

エディタ毎に環境変数を独自に読み込ませているだろうと推測し、それぞれのエディタで環境変数の一覧を取得した。

1
$ printenv
2
TERM_PROGRAM=vscode
3
CURSOR_TRACE_ID=91348...47782

CursorはVSCodeをベースにしているため、どちらもTERM_PROGRAMがvscodeになっている。一方、CURSOR_TRACE_IDはCursor固有の環境変数である。

これを利用して、エディタを特定してコマンドを実行する。

1
import { exec } from "node:child_process";
2

3
function detectEditor() {
4
  if (process.env.TERM_PROGRAM === "vscode") {
5
    if (process.env.CURSOR_TRACE_ID ) {
6
      return "cursor";
7
    }
8
    return "code";
9
  }
10
  return null
11
}
12

13
// ...ファイルを生成する処理
14
const editor = detectEditor();
15
if (editor) {
16
    exec(`${editor} ${fullPath}`);
17
}

Node.jsの標準ライブラリでユーザーの入力を受け付ける#

コマンドの引数を覚えるのは面倒なので、実行してから入力したい。

Node.jsのreadlineモジュールを利用することで、ユーザーの入力を簡単に受け付けることができる。

1
import readline from "node:readline";
2
import { exec } from "node:child_process";
3

4
function askQuestion(rl, question) {
5
  return new Promise((resolve) => {
6
    rl.question(question, (answer) => {
7
      resolve(answer.trim());
8
    });
9
  });
10
}
11

12
const rl = readline.createInterface({
13
    input: process.stdin,
14
    output: process.stdout
15
});
16

17
console.log("Create a new post.");
18
const title = await askQuestion(rl, "Enter the title of the post: ");
19
if (!title) {
20
    console.error("Error: title is required");
21
    process.exit(1);
22
}

大まかな全体の実装#

1
import fs from "node:fs";
2
import path from "node:path";
3
import readline from "node:readline";
4
import { exec } from "node:child_process";
5

6
const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
7

8
function getDate() {
9
  const today = new Date();
10
  const year = today.getFullYear();
11
  const month = String(today.getMonth() + 1).padStart(2, "0");
12
  const day = String(today.getDate()).padStart(2, "0");
13
  return `${year}-${month}-${day}`;
14
}
15

16
async function generateMetadataWithGemini(title) {
17
  const API_URL = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-05-20:generateContent?key=${GEMINI_API_KEY}`;
18

19
  const payload = {
20
    contents: [{
21
      parts: [{
22
        text: `Based on the following blog post title, please generate a URL-friendly English slug and an array of relevant tags. The tags should only include the names of any libraries or services that are likely to be mentioned. \ntitle: "${title}"`
23
      }]
24
    }],
25
    generationConfig: {
26
      responseMimeType: "application/json",
27
      responseSchema: {
28
        type: "OBJECT",
29
        properties: {
30
          slug: {
31
            type: "STRING",
32
            description: "URL-friendly slug in English, using hyphens as separators."
33
          },
34
          tags: {
35
            type: "ARRAY",
36
            items: {
37
              type: "STRING"
38
            },
39
            description: "An array of relevant tags for the blog post, focusing on library and service names."
40
          }
41
        },
42
        required: ["slug", "tags"]
43
      }
44
    }
45
  };
46

47
  try {
48
    const response = await fetch(API_URL, {
49
      method: 'POST',
50
      headers: {
51
        'Content-Type': 'application/json',
52
      },
53
      body: JSON.stringify(payload),
54
    });
55

56
    if (!response.ok) {
57
      const errorBody = await response.text();
58
      throw new Error(`API request failed with status ${response.status}: ${errorBody}`);
59
    }
60

61
    const result = await response.json();
62

63
    if (result.candidates && result.candidates.length > 0 &&
64
        result.candidates[0].content && result.candidates[0].content.parts &&
65
        result.candidates[0].content.parts.length > 0) {
66

67
      const text = result.candidates[0].content.parts[0].text;
68
      return JSON.parse(text);
69
    }
70

71
    console.warn("Warning: No valid metadata was retrieved from Gemini. Generating a basic slug.");
72
    const fallbackSlug = title.toLowerCase().replace(/\s+/g, '-');
73
    return { slug: fallbackSlug, tags: [] };
74

75
  } catch (error) {
76
    console.error("Error calling Gemini API:", error);
77
    throw error;
78
  }
79
}
80

81
function detectEditor() {
82
  if (process.env.TERM_PROGRAM === "vscode") {
83
    if (process.env.CURSOR_TRACE_ID ) {
84
      return "cursor";
85
    }
86
    return "code";
87
  }
88
  return null
89
}
90

91
function askQuestion(rl, question) {
92
  return new Promise((resolve) => {
93
    rl.question(question, (answer) => {
94
      resolve(answer.trim());
95
    });
96
  });
97
}
98

99
async function createNewPost() {
100
  const rl = readline.createInterface({
101
    input: process.stdin,
102
    output: process.stdout
103
  });
104

105
  try {
106
    console.log("Create a new post.");
107

108
    const title = await askQuestion(rl, "Enter the title of the post: ");
109
    if (!title) {
110
      console.error("Error: title is required");
111
      process.exit(1);
112
    }
113

114
    const { slug, tags } = await generateMetadataWithGemini(title);
115

116
    const targetDir = "./contents/posts/";
117
    const postDir = path.join(targetDir, title);
118
    const fullPath = path.join(postDir, "index.md");
119

120
    if (fs.existsSync(fullPath)) {
121
      console.error(`Error: file ${fullPath} already exists`);
122
      process.exit(1);
123
    }
124

125
    // recursive mode creates multi-level directories
126
    if (!fs.existsSync(postDir)) {
127
      fs.mkdirSync(postDir, { recursive: true });
128
    }
129

130
    const content = `---
131
title: ${title}
132
published: ${getDate()}
133
slug: ${slug}
134
draft: true
135
description: ''
136
tags:
137
${tags.map(tag => `  - ${tag}`).join("\n")}
138
---
139

140
`;
141

142
    fs.writeFileSync(fullPath, content);
143

144
    const editor = detectEditor();
145
    if (editor) {
146
      exec(`${editor} ${fullPath}`);
147
    }
148

149
  } catch (error) {
150
    console.error(error);
151
    process.exit(1);
152
  } finally {
153
    rl.close();
154
  }
155
}
156

157
createNewPost();