stars-profile 1.0.0

package/bin/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { run } from '../src/cli.js';
+run();

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "stars-profile",
+  "version": "1.0.0",
+  "description": "Manage GitHub Stars profile contributions using Copilot CLI deep research",
+  "type": "module",
+  "license": "MIT",
+  "author": "Fatih Kadir Akın",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nicedoc/stars-profile.git"
+  },
+  "keywords": [
+    "github",
+    "stars",
+    "contributions",
+    "copilot",
+    "cli"
+  ],
+  "bin": {
+    "stars-profile": "./bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.0.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.0"
+  }
+}

package/src/api.js

@@ -0,0 +1,92 @@
+const API_URL = 'https://api-stars.github.com/';
+
+export const CONTRIBUTION_TYPES = [
+  'SPEAKING',
+  'BLOGPOST',
+  'ARTICLE_PUBLICATION',
+  'EVENT_ORGANIZATION',
+  'HACKATHON',
+  'OPEN_SOURCE_PROJECT',
+  'VIDEO_PODCAST',
+  'FORUM',
+  'OTHER',
+];
+
+async function gql(token, query) {
+  const res = await fetch(API_URL, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ query }),
+  });
+
+  const json = await res.json();
+
+  if (json.errors) {
+    const msg = json.errors.map(e => e.message).join('; ');
+    throw new Error(`GraphQL error: ${msg}`);
+  }
+
+  return json.data;
+}
+
+export async function fetchExistingContributions(token) {
+  const data = await gql(token, '{ contributions { id title url description type date } }');
+  return data.contributions;
+}
+
+export async function createContributions(token, items) {
+  const entries = items.map(item => {
+    const type = item.type ? `type:${item.type}` : '';
+    const escapedTitle = item.title.replace(/"/g, '\\"');
+    const escapedDesc = item.description.replace(/"/g, '\\"');
+    const parts = [
+      `title:"${escapedTitle}"`,
+      `description:"${escapedDesc}"`,
+      `date:"${item.date}"`,
+    ];
+    if (item.url) parts.push(`url:"${item.url}"`);
+    if (type) parts.push(type);
+    return `{ ${parts.join(' ')} }`;
+  });
+
+  const mutation = `mutation {
+    createContributions(data: [${entries.join(', ')}]) {
+      id
+    }
+  }`;
+
+  const data = await gql(token, mutation);
+  return data.createContributions;
+}
+
+export function buildDryCurlCommand(token, items) {
+  const entries = items.map(item => {
+    const url = item.url ? `url:"${item.url}"` : '';
+    const type = item.type ? `type:${item.type}` : '';
+    const escapedTitle = item.title.replace(/"/g, '\\"');
+    const escapedDesc = item.description.replace(/"/g, '\\"');
+    return `              {
+                title:"${escapedTitle}"
+                ${url}
+                description:"${escapedDesc}"
+                ${type}
+                date: "${item.date}"
+              }`;
+  });
+
+  return `curl --location --request POST '${API_URL}' \\
+    --header 'Authorization: Bearer ${token}' \\
+    --header 'Content-Type: application/json' \\
+    --data-raw '{"query":"
+          mutation {
+            createContributions(data:
+              [${entries.join('\n')}])
+              {
+                id
+              }
+          }"
+        ,"variables":{}}'`;
+}

package/src/cli.js

@@ -0,0 +1,161 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { input } from '@inquirer/prompts';
+import { fetchExistingContributions, createContributions, buildDryCurlCommand } from './api.js';
+import { researchActivities } from './research.js';
+import { showExistingSummary, displayNewActivities, selectActivities, confirmSubmission } from './display.js';
+import { getSavedQuery, saveQuery, getSavedToken, saveToken } from './config.js';
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const opts = { query: null, token: null, dryRun: false, help: false };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') {
+      opts.help = true;
+    } else if (arg === '--dry-run') {
+      opts.dryRun = true;
+    } else if ((arg === '--query' || arg === '-q') && args[i + 1]) {
+      opts.query = args[++i];
+    } else if ((arg === '--token' || arg === '-t') && args[i + 1]) {
+      opts.token = args[++i];
+    } else if (!arg.startsWith('-') && !opts.query) {
+      opts.query = arg;
+    }
+  }
+
+  return opts;
+}
+
+function showHelp() {
+  console.log(`
+${chalk.bold('stars-profile')} — Manage GitHub Stars contributions with Copilot CLI deep research
+
+${chalk.bold('USAGE')}
+  npx stars-profile [options] [query]
+
+${chalk.bold('OPTIONS')}
+  -q, --query <text>   Search query (e.g. "fatih kadir akın speeches")
+  -t, --token <token>  Stars API token (default: $GITHUB_STARS_TOKEN)
+      --dry-run        Print the curl command instead of submitting
+  -h, --help           Show this help message
+
+${chalk.bold('EXAMPLES')}
+  npx stars-profile -q "john doe conference talks"
+  npx stars-profile --dry-run -q "jane smith open source"
+  GITHUB_STARS_TOKEN=abc npx stars-profile
+
+${chalk.bold('HOW IT WORKS')}
+  1. Fetches your existing contributions from the Stars API
+  2. Analyzes the language, tone, and style of your entries
+  3. Uses GitHub Copilot CLI to deep-research new activities
+  4. Presents results for review and selection
+  5. Batch-creates selected contributions via the Stars API
+`);
+}
+
+export async function run() {
+  const opts = parseArgs(process.argv);
+
+  if (opts.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  let token = opts.token || process.env.GITHUB_STARS_TOKEN || getSavedToken();
+  if (!token) {
+    token = await input({ message: 'Stars API token (Bearer token):' });
+    if (!token.trim()) {
+      console.error(chalk.red('Error: No Stars API token provided.'));
+      process.exit(1);
+    }
+    saveToken(token.trim());
+    console.log(chalk.dim('Token saved to ~/.config/stars-profile/config.json'));
+  }
+  token = token.trim();
+
+  // Step 1: Fetch existing contributions
+  const fetchSpinner = ora('Fetching existing contributions...').start();
+  let existing;
+  try {
+    existing = await fetchExistingContributions(token);
+    fetchSpinner.succeed(`Fetched ${existing.length} existing contributions`);
+  } catch (err) {
+    fetchSpinner.fail('Failed to fetch contributions');
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+
+  showExistingSummary(existing);
+
+  // Step 2: Get search query
+  let query = opts.query || getSavedQuery();
+  if (query) {
+    console.log(chalk.dim(`Using search query: "${query}"`));
+  } else {
+    query = await input({
+      message: 'Search query (e.g. "your name" + activities):',
+    });
+    if (!query.trim()) {
+      console.error(chalk.red('No search query provided.'));
+      process.exit(1);
+    }
+  }
+  query = query.trim();
+  saveQuery(query);
+
+  // Step 3: Research with Copilot CLI (streams output to terminal)
+  let newActivities;
+  try {
+    newActivities = await researchActivities(query, existing);
+    console.log(chalk.green(`\n✔ Found ${newActivities.length} new activities\n`));
+  } catch (err) {
+    console.error(chalk.red('\n✖ Research failed'));
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+
+  if (newActivities.length === 0) {
+    console.log(chalk.yellow('\nNo new activities found. Try a different search query.'));
+    process.exit(0);
+  }
+
+  // Step 4: Display and select
+  displayNewActivities(newActivities);
+  const selected = await selectActivities(newActivities);
+
+  if (selected.length === 0) {
+    console.log(chalk.yellow('No activities selected.'));
+    process.exit(0);
+  }
+
+  // Step 5: Confirm and submit
+  const proceed = await confirmSubmission(selected);
+  if (!proceed) {
+    console.log(chalk.yellow('Cancelled.'));
+    process.exit(0);
+  }
+
+  // Step 6: Create or dry-run
+  if (opts.dryRun) {
+    console.log(chalk.bold('\n--- Dry run: curl command ---\n'));
+    console.log(buildDryCurlCommand(token, selected));
+    console.log();
+  } else {
+    const createSpinner = ora('Creating contributions...').start();
+    try {
+      const created = await createContributions(token, selected);
+      createSpinner.succeed(`Created ${created.length} contribution(s)`);
+      console.log();
+      for (const c of created) {
+        console.log(`  ${chalk.green('✓')} ${c.id}`);
+      }
+      console.log();
+    } catch (err) {
+      createSpinner.fail('Failed to create contributions');
+      console.error(chalk.red(err.message));
+      process.exit(1);
+    }
+  }
+}

package/src/config.js

@@ -0,0 +1,39 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const CONFIG_DIR = join(homedir(), '.config', 'stars-profile');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n');
+}
+
+export function getSavedQuery() {
+  return readConfig().query || null;
+}
+
+export function saveQuery(query) {
+  const config = readConfig();
+  config.query = query;
+  writeConfig(config);
+}
+
+export function getSavedToken() {
+  return readConfig().token || null;
+}
+
+export function saveToken(token) {
+  const config = readConfig();
+  config.token = token;
+  writeConfig(config);
+}

package/src/display.js

@@ -0,0 +1,93 @@
+import chalk from 'chalk';
+import { checkbox, confirm } from '@inquirer/prompts';
+
+const TYPE_COLORS = {
+  SPEAKING: 'cyan',
+  BLOGPOST: 'green',
+  ARTICLE_PUBLICATION: 'greenBright',
+  EVENT_ORGANIZATION: 'yellow',
+  HACKATHON: 'magenta',
+  OPEN_SOURCE_PROJECT: 'blue',
+  VIDEO_PODCAST: 'red',
+  FORUM: 'gray',
+  OTHER: 'white',
+};
+
+function colorType(type) {
+  const color = TYPE_COLORS[type] || 'white';
+  return chalk[color](type.padEnd(22));
+}
+
+function truncate(str, len) {
+  if (!str) return '';
+  return str.length > len ? str.slice(0, len - 1) + '…' : str;
+}
+
+export function showExistingSummary(contributions) {
+  console.log();
+  console.log(chalk.bold.underline(`Existing contributions: ${contributions.length}`));
+  console.log();
+
+  if (contributions.length === 0) {
+    console.log(chalk.dim('  No existing contributions found. New entries will use a generic format.'));
+    console.log();
+    return;
+  }
+
+  // Count by type
+  const counts = {};
+  for (const c of contributions) {
+    const t = c.type || 'OTHER';
+    counts[t] = (counts[t] || 0) + 1;
+  }
+
+  const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]);
+  for (const [type, count] of sorted) {
+    console.log(`  ${colorType(type)} ${chalk.bold(count)}`);
+  }
+  console.log();
+}
+
+export function displayNewActivities(activities) {
+  console.log(chalk.bold.underline(`Found ${activities.length} new activities:`));
+  console.log();
+
+  for (let i = 0; i < activities.length; i++) {
+    const a = activities[i];
+    const idx = chalk.dim(`${(i + 1).toString().padStart(2)}.`);
+    console.log(`  ${idx} ${colorType(a.type)} ${chalk.bold(truncate(a.title, 60))}`);
+    console.log(`      ${chalk.dim(a.date?.slice(0, 10) || 'no date')}  ${chalk.dim(truncate(a.url || 'no url', 70))}`);
+    console.log(`      ${chalk.dim(truncate(a.description, 80))}`);
+    console.log();
+  }
+}
+
+export async function selectActivities(activities) {
+  const choices = activities.map((a, i) => ({
+    name: `[${a.type}] ${truncate(a.title, 50)} (${a.date?.slice(0, 10) || '?'})`,
+    value: i,
+    checked: true,
+  }));
+
+  const selected = await checkbox({
+    message: 'Select activities to create as contributions:',
+    choices,
+    pageSize: 20,
+  });
+
+  return selected.map(i => activities[i]);
+}
+
+export async function confirmSubmission(items) {
+  console.log();
+  console.log(chalk.bold(`About to create ${items.length} contribution(s):`));
+  for (const item of items) {
+    console.log(`  ${colorType(item.type)} ${item.title}`);
+  }
+  console.log();
+
+  return confirm({
+    message: 'Proceed with creating these contributions?',
+    default: true,
+  });
+}

package/src/research.js

@@ -0,0 +1,265 @@
+import { spawn } from 'node:child_process';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { CONTRIBUTION_TYPES } from './api.js';
+
+function sampleExamples(contributions) {
+  const byType = {};
+  for (const c of contributions) {
+    const t = c.type || 'OTHER';
+    if (!byType[t]) byType[t] = [];
+    byType[t].push(c);
+  }
+
+  const samples = [];
+  for (const [type, items] of Object.entries(byType)) {
+    samples.push(...items.slice(0, 2));
+  }
+  return samples.slice(0, 15);
+}
+
+function detectLanguage(contributions) {
+  if (contributions.length === 0) return null;
+
+  const text = contributions
+    .map(c => `${c.title} ${c.description}`)
+    .join(' ')
+    .toLowerCase();
+
+  const langSignals = {
+    Turkish: ['hakkında', 'konuştum', 'etkinlik', 'üniversitesi', 'çağında', 'hala', 'gerekli', 'topluluk', 'ile', 'için', 'olarak', 'bir'],
+    Portuguese: ['sobre', 'como', 'para', 'uma', 'comunidade', 'desenvolvimento'],
+    Spanish: ['sobre', 'cómo', 'para', 'una', 'comunidad', 'desarrollo', 'habló'],
+    Japanese: ['について', 'です', 'した', 'ます'],
+    Korean: ['에서', '대해', '입니다', '했습니다'],
+  };
+
+  const scores = {};
+  for (const [lang, words] of Object.entries(langSignals)) {
+    scores[lang] = words.filter(w => text.includes(w)).length;
+  }
+
+  const best = Object.entries(scores).sort((a, b) => b[1] - a[1])[0];
+  if (best && best[1] >= 3) {
+    return `primarily English with some ${best[0]} titles/phrases`;
+  }
+
+  return 'English';
+}
+
+// Phase 1: Research prompt — gather data freely, no JSON constraint
+function buildResearchPrompt(query) {
+  return `Do deep research on "${query}" and find their public activities from the LAST 6 MONTHS ONLY (October 2025 – April 2026). Do NOT include older activities.
+
+Specifically search these platforms:
+- X (Twitter): Search x.com/search for recent posts and mentions about this person's talks, projects, and activities
+- LinkedIn: Search linkedin.com for their recent posts, articles, and event announcements
+- YouTube: Search for their recent talks, interviews, and podcast appearances
+- GitHub: Search for their recently active repositories and open source contributions
+- Google: General web search for recent conference appearances, blog posts, and news mentions
+- Dev.to, Medium, personal blogs: Search for articles they've recently written
+
+IMPORTANT: Only include activities from the last 6 months. Skip anything older.
+
+For each activity found, note:
+- What it is (talk, blog post, open source project, video, podcast, event, hackathon, etc.)
+- The title
+- The full URL/link (must be a complete URL starting with https://)
+- A brief description
+- The approximate date
+
+List everything you find. Be thorough — check multiple pages and sources, but only recent items.`;
+}
+
+// Phase 2: Convert prompt — take raw research and convert to structured JSON
+function buildConvertPrompt(researchDataPath, outputPath, existingContributions) {
+  const samples = sampleExamples(existingContributions);
+  const existingUrls = existingContributions
+    .map(c => c.url)
+    .filter(Boolean);
+
+  const language = detectLanguage(existingContributions);
+
+  let styleSection;
+  if (samples.length > 0) {
+    const examplesJson = JSON.stringify(
+      samples.map(({ title, url, description, type, date }) => ({ title, url, description, type, date })),
+      null,
+      2
+    );
+
+    styleSection = `Here are examples of how this person's existing contributions are formatted — match the SAME language, tone, and description style exactly:
+
+${examplesJson}
+
+The detected writing style is ${language}. Write all new entries in the same language and voice as these examples.`;
+  } else {
+    styleSection = `This person has no existing contributions yet. Use a professional, first-person style for descriptions (e.g. "I spoke about X at Y", "A workshop about X for Y").`;
+  }
+
+  const excludeSection = existingUrls.length > 0
+    ? `\nExclude any of these URLs (already recorded):\n${existingUrls.join('\n')}\n`
+    : '';
+
+  return `Read the research data from the file at ${researchDataPath}.
+
+Convert ALL the activities found into a valid JSON array and write it to ${outputPath}.
+
+${styleSection}
+${excludeSection}
+Each object in the JSON array must have exactly these fields:
+- "title": string
+- "url": string or null
+- "description": string (matching the style above)
+- "type": one of: ${CONTRIBUTION_TYPES.join(', ')}
+- "date": ISO 8601 string (e.g. "2025-03-22T00:00:00.000Z")
+
+Write ONLY valid JSON to the output file. No explanations, no markdown — just the raw JSON array.
+Make sure the file is written successfully.`;
+}
+
+function isValidUrl(str) {
+  if (!str || typeof str !== 'string') return false;
+  try {
+    const u = new URL(str);
+    return u.protocol === 'https:' || u.protocol === 'http:';
+  } catch {
+    return false;
+  }
+}
+
+function validateContribution(item) {
+  if (!item || typeof item !== 'object') return null;
+  if (!item.title || !item.description || !item.date) return null;
+  if (item.type && !CONTRIBUTION_TYPES.includes(item.type)) {
+    item.type = 'OTHER';
+  }
+
+  let url = item.url ? String(item.url).trim() : null;
+  // Fix URLs missing protocol
+  if (url && !url.startsWith('http')) {
+    url = 'https://' + url;
+  }
+  // Drop invalid URLs entirely — the API crashes on bad URLs
+  if (url && !isValidUrl(url)) {
+    url = null;
+  }
+
+  return {
+    title: String(item.title),
+    url,
+    description: String(item.description),
+    type: item.type || 'OTHER',
+    date: String(item.date),
+  };
+}
+
+function spawnCopilotStreaming(prompt, timeout = 180_000) {
+  return new Promise((resolve, reject) => {
+    let stdout = '';
+    let stderr = '';
+
+    const proc = spawn('copilot', ['-p', prompt, '--allow-all-tools'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout,
+    });
+
+    proc.stdout.on('data', chunk => {
+      const text = chunk.toString();
+      stdout += text;
+      process.stderr.write(text); // stream to terminal in real-time
+    });
+
+    proc.stderr.on('data', chunk => {
+      stderr += chunk.toString();
+    });
+
+    proc.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        reject(new Error(
+          'GitHub Copilot CLI not found. Install it:\n  npm install -g @github/copilot\nThen authenticate:\n  copilot /login'
+        ));
+      } else {
+        reject(err);
+      }
+    });
+
+    proc.on('close', (code) => {
+      if (code !== 0 && !stdout.trim()) {
+        reject(new Error(`Copilot CLI exited with code ${code}: ${stderr.trim()}`));
+      } else {
+        resolve(stdout);
+      }
+    });
+  });
+}
+
+export async function researchActivities(query, existingContributions) {
+  const timestamp = Date.now();
+  const researchDataPath = join(tmpdir(), `stars-profile-research-${timestamp}.txt`);
+  const outputPath = join(tmpdir(), `stars-profile-results-${timestamp}.json`);
+
+  // Phase 1: Deep research — streams output to terminal
+  console.log('\n--- Phase 1: Deep Research ---\n');
+  const researchOutput = await spawnCopilotStreaming(
+    buildResearchPrompt(query)
+  );
+  console.log('\n');
+
+  // Save research data to temp file for phase 2
+  writeFileSync(researchDataPath, researchOutput);
+  console.log(`Research data saved to: ${researchDataPath}`);
+
+  // Phase 2: Convert to structured JSON
+  console.log('\n--- Phase 2: Converting to structured data ---\n');
+  await spawnCopilotStreaming(
+    buildConvertPrompt(researchDataPath, outputPath, existingContributions)
+  );
+  console.log('\n');
+
+  // Read the JSON output file
+  let jsonContent;
+  try {
+    jsonContent = readFileSync(outputPath, 'utf-8');
+  } catch {
+    throw new Error(
+      `Copilot did not write the JSON output file at ${outputPath}.\nResearch data saved at: ${researchDataPath}`
+    );
+  }
+
+  // Parse JSON
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonContent.trim());
+  } catch {
+    const match = jsonContent.match(/\[[\s\S]*\]/);
+    if (match) {
+      try {
+        parsed = JSON.parse(match[0]);
+      } catch {
+        throw new Error(
+          `Could not parse JSON from output file.\nFile: ${outputPath}\nResearch data: ${researchDataPath}`
+        );
+      }
+    } else {
+      throw new Error(
+        `Invalid JSON in output file.\nFile: ${outputPath}\nResearch data: ${researchDataPath}`
+      );
+    }
+  }
+
+  if (!Array.isArray(parsed)) {
+    throw new Error('Output JSON is not an array.');
+  }
+
+  // Validate and dedup
+  const existingUrls = new Set(
+    existingContributions.map(c => c.url).filter(Boolean)
+  );
+
+  return parsed
+    .map(validateContribution)
+    .filter(Boolean)
+    .filter(item => !item.url || !existingUrls.has(item.url));
+}