John Lindquist

// Name: Widget Dynamic Lists

import "@johnlindquist/kit"

let names = ["John", "Mindy", "Ben", "Scooter"]
let items = _.shuffle(names).map(name => ({ name }))

let html = `
  <div class="flex flex-col w-screen h-screen justify-around items-center">
      <button
      class="rounded px-4 py-2 bg-black bg-opacity-50 hover:bg-opacity-25 w-1/2"
      v-for="(item, index) in items" :key="item.name" :data-name="item.name" :data-index="index">{{index}}. {{item.name}}</button>
      <div>{{selected}}</div>
  </div>  
  `

let w = await widget(html, {
    state: {
      items,
      selected: items[0].name
    }
  }
)

w.onClick(event => {
  if (event.dataset.name) {
    w.setState({selected: event.dataset.name})
  }
})

setInterval(() => {
  items = _.shuffle(items)
  w.setState({
    items,
  })
}, 1000)

import "@johnlindquist/kit"

// Menu: Chrome History
// Description: Open a url from your history
// Author: John Lindquist
// Twitter: @johnlindquist

let historyFilePath = home(
  "Library/Application Support/Google/Chrome/Default/History"
)

// ~/.kenv/tmp/chrome-history/History
let tmpHistoryPath = tmpPath("History")

// We make copy of the db each time or you run into a SQL_BUSY if Chrome is open
await copyFile(historyFilePath, tmpHistoryPath)

let sqlite3 = await npm("sqlite3")
let db = new sqlite3.Database(tmpHistoryPath)
let limit = 1000
let sql = `SELECT url, title, last_visit_time FROM urls ORDER BY last_visit_time DESC LIMIT ${limit}`

let callback = async (err, rows) => {
  let url = await arg(
    "Chrome History",
    rows.map(({ url, title }) => {
      return {
        name: title,
        description: url,
        value: url,
      }
    })
  )

  open(url)
}

db.all(sql, callback)
db.close()

// Name: Get Data from a Widget

import "@johnlindquist/kit"

let state = {
  firstName: "",
  lastName: "",
  fullName: "",
}

let w = await widget(
  `
<div class="flex flex-col justify-center items-center text-white">
    <form class="flex flex-col">
        <input id="first" type="text" class="text-black" placeholder="First Name" autofocus>
        <input id="last" type="text" class="text-black" placeholder="Last Name">
        <button id="submit" type="submit">Submit</button>
    </form>
    <div class="flex flex-col">
        <div>{{firstName}} {{lastName}}</div>        
        <div>{{fullName}}</div>
    </div>
</div>
`,
  {
    height: 360,
    width: 360,
    state,
  }
)

w.onInput(event => {
  if (event.targetId === "first") {
    state.firstName = event.value
  }
  if (event.targetId === "last") {
    state.lastName = event.value
  }

  w.setState(state)
})

w.onClick(event => {
  if (event.targetId === "submit") {
    state.fullName = `Hello, ${state.firstName} ${state.lastName}`
  }

  w.setState(state)
})

// Name: Post URL with Metadata to Tana

import "@johnlindquist/kit"

let og = await npm("opengraph-io")

// You'll need to sign-up for https://www.opengraph.io/
// Create a free account and grab an API key from: https://dashboard.opengraph.io/apis/Opengraphio
// Paste the token when prompted for OPENGRAPH_API_ID_TOKEN
let openGraph = og({
  appId: await env("OPENGRAPH_API_ID_TOKEN", {
    hint: `Grab a token from [here](https://dashboard.opengraph.io/apis/Opengraphio)`,
  }),
  cacheOk: true, // If a cached result is available, use it for quickness
  useProxy: false, // Proxies help avoid being blocked and can bypass capchas
  maxCacheAge: 432000000, // The maximum cache age to accept
  acceptLang: "en-US,en;q=0.9", // Language to present to the site.
  fullRender: false, // This will cause JS to execute when rendering to deal with JS dependant sites
})

let url = await getActiveTab()
// on windows, remove above and use:
// let url = await arg("Paste URL here")

let result = await openGraph.getSiteInfo(url)
debugger

if (result.openGraph.error) {
  await editor(result.openGraph.error)
} else {
  let { title, site_name, description } = result.openGraph

  // In the future, Tana will support more than just raw text
  // For now, only text is supported.

  // This gives you a chance to tweak the Title/Description before posting:
  let note = await template(
    `
${title} - ${site_name}
    - ${url}
    - ${description}
    `.trim()
  )

  let TANA_URL =
    "https://europe-west1-tagr-prod.cloudfunctions.net"

  // Select a node in Tana, hit cmd+K from mac, ctrl+K for windows, search for "API" to generate a token
  // Paste the token when prompted
  let TANA_TOKEN_TODOS = await env("TANA_TOKEN_TODOS_TWO")
  await hide()
  //   await copy(note.trim()) if you prefer to copy/paste you can use this instead
  await get(`${TANA_URL}/addToNode`, {
    headers: {
      authorization: `Bearer ${TANA_TOKEN_TODOS}`,
    },
    params: {
      note: note.trim(),
    },
  })
}
debugger

// Name: Grab Readwise Highlights

import "@johnlindquist/kit"

let API_TOKEN = await env("TANA_API_TOKEN")
let HIGHLIGHTS_URL = "https://readwise.io/api/v2/export/"

// Credit to: https://github.com/tanainc/tana-paste-examples
// Copy/pasted and refactored to Script Kit: scriptkit.com

let getItemsFromReadwise = async (daysToFetch = 1) => {
  let dateOffset = 24 * 60 * 60 * 1000 * daysToFetch
  let updatedAfterDate = new Date()
  updatedAfterDate.setTime(
    updatedAfterDate.getTime() - dateOffset
  )

  let response = await fetch(
    `${HIGHLIGHTS_URL}?updatedAfter=${updatedAfterDate.toISOString()}`,
    {
      headers: {
        Authorization: `Token ${API_TOKEN}`,
      },
    }
  )
  return await response.json()
}

let daysToFetch = await arg("Days to fetch")
let { results } = await getItemsFromReadwise(
  parseInt(daysToFetch, 10)
)

let result = results.map(book => {
  let isValidSourceURL =
    book.source_url?.startsWith("https://")
  let hasHighlights = book.highlights?.length > 0

  let title = `${book.title}`
  let url = ``
  if (isValidSourceURL) {
    url = `URL:: ${book.source_url}`
  }
  let type = `type:: ${book.category?.replace(/s$/, "")}`

  let author = `author:: ${book.author}`

  let highlights = book.highlights.map(highlight => {
    let lines = highlight.text.split("\n")
    let cleanLines = lines.map(line => {
      let cleanedLine = line.replace(/•\s+/, "").trim()
      return `${cleanedLine}`
    })

    let note = ``

    if (highlight.note) {
      note = `${highlight.note}`
    }

    return `
${cleanLines}   

${note}
    `.trim()
  })

  let maybeUrl = url
    ? `
    - ${url}
`
    : ``

  let maybeHighlights = highlights?.length
    ? `
    - Highlights
        - ${highlights.join("\n")}`
    : ``

  return `
- ${title} #from-the-web 
${maybeUrl}
    - ${type}
    - ${author}
${maybeHighlights}    
  `.trim()
})

// because I'm on a trial account (I assume)
let [skip, ...rest] = result

// copies the readwise content to the clipboard
// I'm using slice to only take 2 results for demo purposes
await copy(`%%tana%%

${rest.slice(0, 2).join("\n")}
`)

// Name: Restart Opal

import "@johnlindquist/kit"

let fkill = await npm("fkill")
let open = await npm("open")

let app = "Opal"

console.log(`Closing Opal`)

try {
  fkill(app, { silent: true })
} catch {
  console.log(`Wasn't running...`)
}

await wait(1000)

console.log(`Opening Opal`)

await open.openApp(app)

// Name: Synonym Snippet
// Snippet: *,,

import "@johnlindquist/kit"

let word = await arg("The value of *")

let response = await get(`https://api.datamuse.com/words?ml=${word}`)

let synonyms = response.data.map(i => i.word)

let synonym = await arg("Select a replacement", synonyms)

await setSelectedText(synonym)

// Name: Midjourney Prompt
// Description: Generate a Random Midjourney Prompt
// Author: John Lindquist
// Twitter: @johnlindquist

import "@johnlindquist/kit"

let count = parseInt(
  await arg({
    placeholder: "How many prompts to generate and paste?",
    onInput: input => {
      submit(input) //auto submit the number on press
    },
  }),
  10
)

let frontmost = await npm("frontmost-app")

let exitIfNotDiscord = async () => {
  let { localizedName: name } = await frontmost()
  if (name !== "Discord") {
    exit()
  }
}

await exitIfNotDiscord()

let n = (x = 0) =>
  `::${Number(_.random(0.2, 2.2) + x).toPrecision(1)}`

let iw = (x = 0) =>
  `${Number(_.random(0.2, 2.2) + x).toPrecision(1)}`

let parentDir = await env(
  "MIDJOURNEY_PARENT_DIR",
  async () => {
    return await path({
      hint: `Select a parent dir to clone the repo: https://github.com/johnlindquist/midjourney`,
    })
  }
)

let mjDir = path.resolve(parentDir, "midjourney")

let mjExists = await isDir(mjDir)

if (!mjExists) {
  cd(parentDir)
  await exec(
    `git clone https://github.com/johnlindquist/midjourney`
  )
  cd(mjDir)
} else {
  cd(mjDir)
  await exec(`git pull`)
}

// await wiki() will pull a random wikipedia title
let wiki = await npm("random-word-wikipedia")

// Generate functions based on .md files in the repo
let files = await readdir(mjDir)
files = files.filter(file => file.endsWith(".md"))

for await (let file of files) {
  let filePath = path.resolve(mjDir, file)
  let list = await readFile(filePath, "utf-8")
  let { name } = path.parse(filePath)
  global[name] = () => _.sample(list.trim().split("\n"))
}

hide()

let go = async () => {
  await exitIfNotDiscord()

  // Customize however you want. More old "maybe working" examples here: https://github.com/johnlindquist/midjourney/blob/main/prompts.md
  let fnsPrompt = `/imagine prompt: ${image()} ${myimage()} Studio photoshoot of ${celeb()} ${animal()} ${hero()}::4 ${await wiki()}${n()} in a ${color()} ${climate()}${n()} in the style of ${game()}${n()} taken by ${photographer()}${n()} by ${artist()}${n()} stylized like ${style()} and ${rank()}${n()} --stylize ${_.random(
    1000,
    3000
  )} --uplight --aspect 16:9 --iw ${iw()}`

  let prompt = _.sample([fnsPrompt])

  await exitIfNotDiscord()

  await setSelectedText(prompt)
  log(prompt)

  await wait(1000)

  await exitIfNotDiscord() //I try to be extra careful when scripting the `Enter` key

  await keyboard.pressKey(Key.Enter)
  await keyboard.releaseKey(Key.Enter)
  await wait(250) // Discord needs a sec after paste+enter to recorgnize it as a command

  await exitIfNotDiscord()

  await keyboard.pressKey(Key.Enter)
  await keyboard.releaseKey(Key.Enter)
}

let i = 0

while (i < count) {
  i++
  await go()
  await wait(1000)
}

// Name: xstate widget

import "@johnlindquist/kit"

let { createMachine, interpret } = await npm("xstate")

let initial = 'inactive'
let toggleMachine = createMachine({
    id: 'toggle',
    initial,
    states: {
        inactive: { on: { TOGGLE: 'active' } },
        active: { on: {TOGGLE: 'inactive'}}
    }
})

// Widgets use "petite-vue" templating with state on the root
// This allows to send a state object
let w = await widget(`
<div class="p-4 text-4xl">
    <button>Click</button>
    <div>{{ value === "active" ? "💚" : "💔"}}<div>
</div>`, {
    state: {
        value: initial
    }
})

let toggleService = interpret(toggleMachine)
    .onTransition(state => {
        log(state) // ~/.kenv/logs/xstate-widget.log
        w.setState(state)
    })
    .start()

w.onClick(() => {
    toggleService.send('TOGGLE')
})

// Name: Download Chrome Video
// Description: Downloads the video of the current Chrome page
// Author: John Lindquist
// Twitter: @johnlindquist
// REQUIRES https://formulae.brew.sh/formula/youtube-dl

import "@johnlindquist/kit"
import Stream from "stream"

let writeableStream = new Stream.Writable()
writeableStream._write = (chunk, encoding, next) => {
    console.log(chunk.toString().trim())
    next()
}

cd(await path())

let url = await getActiveTab()

setChoices(null)
setDescription(`Downloading ${url}...`)
setInput(``)
setPlaceholder(`Please wait...`)

exec(`/opt/homebrew/bin/youtube-dl ${url}`, {all: true}).all.pipe(writeableStream)

// Name: Homebrew Search
// Description: Search and Install Homebrew Formulae
// Author: John Lindquist
// Twitter: @johnlindquist

import "@johnlindquist/kit"

let response = await get(`https://formulae.brew.sh/api/formula.json`)

let homebrewChoices = response.data.map(({name, tap}) => {
    return {
        name,
        value: name,
        description: tap,
        preview: async ()=> {
            let response = await get(`https://formulae.brew.sh/api/formula/${name}.json`)
            let {full_name, tap, desc, homepage, versions, urls} = response.data
            return md(`## ${full_name}
### ${tap}

${desc}
[${homepage}](${homepage})

* Version - ${versions?.stable}
* URLs - ${urls?.stable?.url}


 `)
        }

    }
})

let formula = await arg("Search homebrew", homebrewChoices)

let bins = await readdir(`/opt/homebrew/bin`)

let installed = bins.includes(formula)

if(installed){
    setDescription(`${formula} already installed`)
}

let message = `${installed ? `Uninstall` : `Install`} ${formula}?`

let confirm = await arg(message, [
    {name: `[y]es`, value: true},
    {name: `[n]o`, value: false}
])

setChoices(null)
setPlaceholder(`Please wait...`)


if(confirm){
    setDescription(`${installed ? `Uninstalling` : `Installing`} ${formula}`)
    await exec(`/opt/homebrew/bin/brew ${installed ? `uninstall` : `install`} ${formula}`)
}

// Name: Toggle Desktop Icons
// Author: John Lindquist
// Twitter: @johnlindquist

import "@johnlindquist/kit"

let visible = true

try{
    // This command fails if icons are hidden
    let {stdout} = await exec(`defaults read com.apple.finder CreateDesktop`)
    visible = stdout === 1
}catch{}

let command = `defaults ${visible ? "write" : "delete"} com.apple.finder CreateDesktop ${visible ? "-bool FALSE" : ""};killall Finder`

await exec(command)

// Name: Grab Caption

import "@johnlindquist/kit"

// This query selector is specific to Disney plus
let js = `

Array.from(document.querySelectorAll('.dss-subtitle-renderer-line')).map(el => el.innerText)

`

let value = await applescript(`
tell application "Google Chrome" to tell window 1
	set str to execute active tab javascript "${js}"
	return str
end tell
`)

await div(md(`## ${value}`))

// To copy to clipboard, use:
// copy(value)