"activationEvents": [
  "onLanguage:markdown"
],

export function activate(context: vscode.ExtensionContext) {
  const writeAssist: WriteAssistAI = new WriteAssistAI();
  const aiActionProvider = vscode.languages.registerCodeActionsProvider(
    'markdown',
    writeAssist,
    {
      providedCodeActionKinds: WriteAssistAI.providedCodeActionKinds,
    }
  );

  context.subscriptions.push(aiActionProvider);
  for (const command of writeAssist.commands) {
    context.subscriptions.push(
      vscode.commands.registerCommand(command, () =>
        writeAssist.handleAction(command)
      )
    );
  }
}

"contributes": {
  "configuration": {
    "title": "Write Assist AI",
    "properties": {
      "writeAssistAi.openAiApiKey": {
        "type": "string",
        "default": "",
        "description": "Enter you OpenAI API Key here"
      },
      "writeAssistAi.maxTokens": {
        "type": "number",
        "default": 1200,
        "description": "Enter the maximum tokens to use for each OpenAI API call"
      }
    }
  }
},

npx nuxi init -t themes/content-wind my-website

// For format details, see https://aka.ms/devcontainer.json. For config options, see the
// README at: https://github.com/devcontainers/templates/tree/main/src/typescript-node
{
  "name": "gh-blog",
  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
  "image": "mcr.microsoft.com/devcontainers/typescript-node:0-18-bullseye",
  "hostRequirements": {
    "cpus": 4
  },

  // Features to add to the dev container. More info: https://containers.dev/features.
  // "features": {},

  // Use 'forwardPorts' to make a list of ports inside the container available locally.
  "forwardPorts": [3000],
  "portsAttributes": {
    "3000": {
      "label": "Application",
      "onAutoForward": "openPreview"
    }
  },

  "waitFor": "onCreateCommand",
  // install the dependencies automatically
  "updateContentCommand": "yarn install",
  "postCreateCommand": "",
  // As soon as the container is attached run the nuxt server in dev mode
  "postAttachCommand": "yarn dev",

  // Add the needed customizations & extensions
  "customizations": {
    "vscode": {
      "extensions": [
        "Vue.volar",
        "Vue.vscode-typescript-vue-plugin",
        "dbaeumer.vscode-eslint",
        "esbenp.prettier-vscode",
        "ra-jeev.write-assist-ai",
        "DavidAnson.vscode-markdownlint"
      ]
    }
  }

  // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
  // "remoteUser": "root"
}

const functions = require('firebase-functions');
const { Octokit } = require('@octokit/rest');
const admin = require('firebase-admin');
const cors = require('cors');

const { defineSecret, defineString } = require('firebase-functions/params');
const githubToken = defineSecret('github_token');
const codespaceName = defineString('GITHUB_CODESPACE_NAME');

admin.initializeApp();

exports.startCodespaces = functions
  .region('europe-west1')
  .runWith({ secrets: [githubToken] })
  .https.onRequest(async (req, resp) => {
    functions.logger.info('Incoming startCodespaces req!', {
      structuredData: true,
    });

    cors({ origin: true })(req, resp, async () => {
      // Verify that the calling user is an ADMIN
      if (
        req.headers.authorization &&
        req.headers.authorization.startsWith('Bearer ')
      ) {
        const idToken = req.headers.authorization.split('Bearer ')[1];
        const decodedToken = await admin.auth().verifyIdToken(idToken);

        functions.logger.log('decodedToken', decodedToken);

        if (decodedToken.roles && decodedToken.roles.includes('ADMIN')) {
          const octokit = new Octokit({
            auth: githubToken.value(),
          });

          functions.logger.log('codespace name:', codespaceName.value());
          try {
            const codespace =
              await octokit.codespaces.startForAuthenticatedUser({
                codespace_name: codespaceName.value(),
              });

            functions.logger.log('got some codespace response', codespace);

            return resp.status(200).send(JSON.stringify(codespace.data));
          } catch (error) {
            functions.logger.error(error);
            resp
              .status(500)
              .send(error.message || 'Failed to start the workspace');
          }
        }
      }

      resp.status(401).send('Not authorized');
    });
  });

name: Deploy to GitHub Pages

on:
  push:
    branches:
      - main

  workflow_dispatch:

permissions:
  contents: read
  pages: write
  id-token: write

concurrency:
  group: 'pages'
  cancel-in-progress: false

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout
        uses: actions/checkout@v3

      - name: Detect package manager
        id: detect-package-manager
        run: |
          if [ -f "${{ github.workspace }}/yarn.lock" ]; then
            echo "manager=yarn" >> $GITHUB_OUTPUT
            echo "command=install" >> $GITHUB_OUTPUT
            exit 0
          elif [ -f "${{ github.workspace }}/package.json" ]; then
            echo "manager=npm" >> $GITHUB_OUTPUT
            echo "command=ci" >> $GITHUB_OUTPUT
            exit 0
          else
            echo "Unable to determine package manager"
            exit 1
          fi

      - name: Setup node env
        uses: actions/setup-node@v3
        with:
          node-version: 18
          cache: ${{ steps.detect-package-manager.outputs.manager }}

      - name: Setup Pages
        uses: actions/configure-pages@v3

      - name: Restore cache
        uses: actions/cache@v3
        with:
          path: |
            .output/public
            .nuxt
          key: ${{ runner.os }}-nuxt-build-${{ hashFiles('.output/public') }}
          restore-keys: |
            ${{ runner.os }}-nuxt-build-

      - name: Install dependencies
        run: ${{ steps.detect-package-manager.outputs.manager }} ${{ steps.detect-package-manager.outputs.command }}

      - name: Generate the static files
        run: ${{ steps.detect-package-manager.outputs.manager }} run generate
        env:
          # Setting an environment variable with the value of a configuration variable
          FIREBASE_API_KEY: ${{ vars.FIREBASE_API_KEY }}
          FIREBASE_AUTH_DOMAIN: ${{ vars.FIREBASE_AUTH_DOMAIN }}
          FIREBASE_PROJECT_ID: ${{ vars.FIREBASE_PROJECT_ID }}
          FIREBASE_STORAGE_BUCKET: ${{ vars.FIREBASE_STORAGE_BUCKET }}
          FIREBASE_MESSAGING_SENDER_ID: ${{ vars.FIREBASE_MESSAGING_SENDER_ID }}
          FIREBASE_APP_ID: ${{ vars.FIREBASE_APP_ID }}
          START_CODESPACE_FN_URL: ${{ vars.START_CODESPACE_FN_URL }}

      - name: Upload artifact
        uses: actions/upload-pages-artifact@v1
        with:
          path: .output/public

  # Deployment job
  deploy:
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}

    runs-on: ubuntu-latest

    needs: build

    steps:
      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v2

export default defineNuxtConfig({
  extends: 'content-wind',
  app: {
    baseURL: '/gh-blog/', // baseURL: '/<repository_name>/'
  },
})

name: Create drafts on dev.to

on:
  push:
    branches:
      - main
    paths:
      - 'content/blog/**.md'

permissions:
  contents: read

jobs:
  new-posts-check:
    runs-on: ubuntu-latest

    outputs:
      num_added_files: ${{ steps.get_new_files.outputs.num_added_files }}
      new_files: ${{ steps.get_new_files.outputs.new_files }}

    steps:
      - name: Get Files Added
        id: get_new_files
        env:
          GH_TOKEN: ${{ github.token }}
        run: |
          gh api \
            -H "Accept: application/vnd.github+json" \
            -H "X-GitHub-Api-Version: 2022-11-28" \
            /repos/${{ github.repository }}/compare/${{ github.event.before }}...${{ github.event.after }} > /tmp/diff_data.json

          new_files=$(jq -c '.files | map(select(.status == "added" and (.filename | startswith("content/blog"))) | {filename})' /tmp/diff_data.json)
          echo "new files = $new_files"

          num_added_files=$(echo "$new_files" | jq length)
          echo "num_added_files = $num_added_files"

          echo "num_added_files=$num_added_files" >> "$GITHUB_OUTPUT"
          echo "new_files=$new_files" >> "$GITHUB_OUTPUT"

  parse-and-create-drafts:
    needs: new-posts-check
    runs-on: ubuntu-latest

    if: needs.new-posts-check.outputs.num_added_files > 0

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Setup node env
        uses: actions/setup-node@v3
        with:
          node-version: 18
          cache: npm

      - name: Install dependencies
        run: npm install axios gray-matter

      - name: Parse markdown files and create drafts
        env:
          DEV_API_KEY: ${{ secrets.DEV_API_KEY }}
          GH_PAGES_WEB_URL: 'https://${{github.repository_owner}}.github.io/${{github.event.repository.name}}'
        run: |
          node ./scripts/parseAndCreateDrafts.js '${{ needs.new-posts-check.outputs.new_files }}'

const matter = require('gray-matter');
const { readFileSync } = require('fs');
const axios = require('axios');

// Function to create a draft on dev.to
async function createDraftPostOnDev(article) {
  try {
    const res = await axios.post(
      'https://dev.to/api/articles',
      { article },
      {
        headers: {
          'api-key': process.env.DEV_API_KEY,
          accept: 'application/vnd.forem.api-v1+json',
        },
      }
    );

    console.log(`Article posted successfully:  ${res.data.url}`);

    return res.data;
  } catch (error) {
    console.error('Failed to post the article:', error);
  }
}

// Function to parse Markdown file using gray-matter
function parseMarkdownFile(filename) {
  try {
    const fileContent = readFileSync(filename, 'utf8');
    const { data, content } = matter(fileContent);

    const post = {
      title: data.title,
      description: data.description,
      body_markdown: content,
      canonical_url:
        process.env.GH_PAGES_WEB_URL +
        filename.split('content')[1].replace('.md', ''),
    };

    if (data.image?.src) {
      post.main_image = process.env.GH_PAGES_WEB_URL + data.image.src;
    }

    console.log('final post', post);
    return post;
  } catch (error) {
    console.error('Error:', error);
  }
}

const main = async () => {
  const args = process.argv.slice(2);

  const filenames = JSON.parse(args[0]);

  const res = [];
  for (const file of filenames) {
    const post = parseMarkdownFile(file.filename);
    if (post) {
      const result = await createDraftPostOnDev(post);
      if (result) {
        res.push(result);
      }

      // Wait for 5 seconds before posting another article
      // This is to avoid getting 429 Too Many Requests error
      // from the dev.to API
      await new Promise((r) => setTimeout(r, 5000));
    }
  }

  console.log('res:', res);
};

main();