@coreframe/scripts 0.1.0 → 0.1.2

package/dev.ts

@@ -1,155 +0,0 @@
-#!/usr/bin/env node
-import { spawn as nodeSpawn } from "node:child_process"
-import { createWriteStream } from "node:fs"
-import { mkdir } from "node:fs/promises"
-import path from "node:path"
-import process from "node:process"
-import type { Readable } from "node:stream"
-
-type Spawn = typeof nodeSpawn
-type TeeProcess = {
-  on(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): void
-  on(event: "error", listener: (error: Error) => void): void
-  stderr: Readable | null
-  stdout: Readable | null
-}
-
-export type DevServerOptions = {
-  cwd?: string
-  env?: NodeJS.ProcessEnv
-  logPath?: string
-  platform?: DevPlatform
-  spawn?: Spawn
-}
-
-export type DevPlatform = "android" | "desktop" | "ios" | "web"
-
-const defaultLogPath = ".agents/logs/dev-server.log"
-const nodeModulesBinPath = path.resolve("node_modules", ".bin")
-const pnpmCommand = process.platform === "win32" ? "pnpm.cmd" : "pnpm"
-const reactRouterCommand =
-  process.platform === "win32" ? "react-router.cmd" : "react-router"
-
-export async function runDevServer({
-  cwd = process.cwd(),
-  env = process.env,
-  logPath = defaultLogPath,
-  platform = "web",
-  spawn = nodeSpawn,
-}: DevServerOptions = {}) {
-  const pathEnvValue = env.PATH ?? env.Path ?? ""
-  const shouldTee = !("TAURI_ENV_PLATFORM" in env)
-  const log = shouldTee ? await createDevLog(logPath) : undefined
-
-  try {
-    if (platform === "web") {
-      await runDevProcess(spawn, pnpmCommand, ["db", "ensure"], {
-        cwd,
-        env,
-        log,
-      })
-
-      await runDevProcess(spawn, reactRouterCommand, ["dev"], {
-        cwd,
-        env: {
-          ...env,
-          CLOUDFLARE_ENV: "development",
-          PATH: nodeModulesBinPath + path.delimiter + pathEnvValue,
-        },
-        log,
-      })
-      return
-    }
-
-    await runDevProcess(spawn, pnpmCommand, tauriDevArgs(platform), {
-      cwd,
-      env,
-      log,
-    })
-  } finally {
-    await closeLog(log)
-  }
-}
-
-async function createDevLog(logPath: string) {
-  await mkdir(path.dirname(logPath), { recursive: true })
-  return createWriteStream(logPath, { flags: "w" })
-}
-
-function closeLog(log: NodeJS.WritableStream | undefined) {
-  if (!log) {
-    return Promise.resolve()
-  }
-
-  return new Promise<void>((resolve, reject) => {
-    log.once("error", reject)
-    log.end(resolve)
-  })
-}
-
-function tauriDevArgs(platform: Exclude<DevPlatform, "web">) {
-  return ["--dir=tauri", "tauri", ...(platform === "desktop" ? [] : [platform]), "dev"]
-}
-
-function runDevProcess(
-  spawn: Spawn,
-  command: string,
-  args: string[],
-  {
-    cwd,
-    env,
-    log,
-  }: {
-    cwd: string
-    env: NodeJS.ProcessEnv
-    log: NodeJS.WritableStream | undefined
-  },
-) {
-  return new Promise<void>((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd,
-      env,
-      stdio: log ? ["inherit", "pipe", "pipe"] : "inherit",
-    }) as unknown as TeeProcess
-
-    if (log) {
-      if (!child.stdout || !child.stderr) {
-        reject(new Error(`${[command, ...args].join(" ")} did not provide output streams`))
-        return
-      }
-
-      child.stdout.on("data", (chunk) => {
-        process.stdout.write(chunk)
-        log.write(chunk)
-      })
-
-      child.stderr.on("data", (chunk) => {
-        process.stderr.write(chunk)
-        log.write(chunk)
-      })
-    }
-
-    child.on("error", reject)
-
-    child.on("close", (code, signal) => {
-      if (code === 0) {
-        resolve()
-        return
-      }
-
-      const commandText = [command, ...args].join(" ")
-      reject(
-        new Error(
-          `${commandText} failed${signal ? ` with signal ${signal}` : ` with exit code ${code ?? 1}`}`,
-        ),
-      )
-    })
-  })
-}
-
-if (import.meta.main) {
-  runDevServer().catch((error) => {
-    console.error(error)
-    process.exit(1)
-  })
-}

package/image-generator.ts

@@ -1,84 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-
-import type sharp from "sharp"
-import { glob } from "tinyglobby"
-import type { Plugin } from "vite"
-
-type SharpFactory = typeof sharp
-
-export function imageGenerator(): Plugin {
-  return {
-    name: "image-generator",
-    async buildStart() {
-      const files = await glob(["src/**/*@3x.{png,webp}", "public/**/*@3x.{png,webp}"])
-
-      console.log(`[image-generator] Found ${files.length} @3x images.`)
-
-      await Promise.all(files.map((file) => generateDensityImages(file)))
-    },
-  }
-}
-
-async function generateDensityImages(file: string) {
-  const dir = path.dirname(file)
-  const ext = path.extname(file)
-  const base = path.basename(file, `@3x${ext}`)
-  const outputImages = [
-    {
-      outputPath: path.join(dir, `${base}@2x${ext}`),
-      scale: 2 / 3,
-    },
-    {
-      outputPath: path.join(dir, `${base}@1x${ext}`),
-      scale: 1 / 3,
-    },
-  ].filter((image) => !fs.existsSync(image.outputPath))
-
-  if (outputImages.length === 0) {
-    return
-  }
-
-  const { default: sharp } = await import("sharp")
-  let width: number | undefined
-
-  try {
-    width = (await sharp(file).metadata()).width
-  } catch (error) {
-    console.error(`[image-generator] Failed to read metadata for ${file}`, error)
-    return
-  }
-
-  if (!width) {
-    console.error(`[image-generator] Skipping ${file}; image width could not be read.`)
-    return
-  }
-
-  await Promise.all(
-    outputImages.map((image) =>
-      generateDensityImage({
-        file,
-        outputPath: image.outputPath,
-        sharp,
-        width: Math.round(width * image.scale),
-      }),
-    ),
-  )
-}
-
-async function generateDensityImage(options: {
-  file: string
-  outputPath: string
-  sharp: SharpFactory
-  width: number
-}) {
-  try {
-    console.log(`[image-generator] Generating ${options.outputPath} (${options.width}w)`)
-    await options.sharp(options.file).resize({ width: options.width }).toFile(options.outputPath)
-  } catch (error) {
-    console.error(
-      `[image-generator] Failed to process ${options.file} for ${options.outputPath}`,
-      error,
-    )
-  }
-}

package/project.ts

@@ -1,6 +0,0 @@
-import { resolve } from "node:path"
-import { pathToFileURL } from "node:url"
-
-export async function importProjectModule<T>(path: string): Promise<T> {
-  return (await import(pathToFileURL(resolve(process.cwd(), path)).href)) as T
-}

package/tsconfig.build.json

@@ -1,12 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "allowImportingTsExtensions": false,
-    "declaration": true,
-    "emitDeclarationOnly": false,
-    "noEmit": false,
-    "outDir": "dist",
-    "rewriteRelativeImportExtensions": true
-  },
-  "exclude": ["**/*.test.ts", "**/*.test.tsx", "dist"]
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "allowImportingTsExtensions": true,
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "isolatedModules": true,
-    "lib": ["ES2022", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "noEmit": true,
-    "resolveJsonModule": true,
-    "rootDir": ".",
-    "skipLibCheck": true,
-    "strict": true,
-    "target": "ES2022",
-    "types": ["node"]
-  },
-  "include": ["**/*.ts"]
-}

package/typecheck.ts

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-import { access } from "node:fs/promises"
-import path from "node:path"
-import process from "node:process"
-
-import { supervise } from "procband"
-
-const nodeModulesBinPath = path.resolve("node_modules", ".bin")
-process.env.PATH = nodeModulesBinPath + path.delimiter + process.env.PATH
-
-const tscCommand = process.platform === "win32" ? "tsc.cmd" : "tsc"
-const projects = [
-  { name: "scripts", path: "scripts/tsconfig.json" },
-  { name: "shared", path: "src/shared/tsconfig.json" },
-  { name: "api", path: "src/api/tsconfig.json" },
-  { name: "worker", path: "src/api/worker/tsconfig.json" },
-  { name: "web", path: "src/web/tsconfig.json" },
-] as const
-
-export async function typecheckProject() {
-  const existingProjects = []
-
-  for (const project of projects) {
-    try {
-      await access(project.path)
-      existingProjects.push(project)
-    } catch (error) {
-      if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
-        throw error
-      }
-    }
-  }
-
-  const checks = existingProjects.map((project) =>
-    supervise({
-      name: project.name,
-      command: tscCommand,
-      args: ["-p", project.path],
-    }),
-  )
-
-  const results = await Promise.all(checks.map((check) => check.wait()))
-  const failed = results.filter((result) => result.exitCode !== 0)
-
-  if (failed.length > 0) {
-    process.exitCode = failed[0].exitCode
-  }
-}
-
-if (import.meta.main) {
-  typecheckProject().catch((error) => {
-    console.error(error)
-    process.exit(1)
-  })
-}

package/upgrade/check-skill-current.ts

@@ -1,112 +0,0 @@
-#!/usr/bin/env node
-import { spawnSync } from "node:child_process"
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-
-const skillPath = ".agents/skills/coreframe-upgrade/SKILL.md"
-
-export type CheckUpgradeSkillOptions = {
-  apply: boolean
-  target: string
-}
-
-function git(args: string[], options: { encoding?: BufferEncoding } = {}) {
-  return spawnSync("git", args, options)
-}
-
-function errorDetail(result: ReturnType<typeof spawnSync>) {
-  return result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim()
-}
-
-function readGitFile(ref: string, path: string) {
-  const result = git(["show", `${ref}:${path}`], { encoding: "utf8" })
-
-  if (result.status !== 0) {
-    const detail = errorDetail(result)
-    throw new Error(`Could not read ${path} at ${ref}.${detail ? ` ${detail}` : ""}`)
-  }
-
-  return result.stdout.toString()
-}
-
-function getRepoRoot() {
-  const result = git(["rev-parse", "--show-toplevel"], { encoding: "utf8" })
-
-  if (result.status !== 0) {
-    const detail = errorDetail(result)
-    throw new Error(`Could not find git repository root.${detail ? ` ${detail}` : ""}`)
-  }
-
-  return result.stdout.toString().trim()
-}
-
-function printDiff(localPath: string, targetText: string) {
-  const dir = mkdtempSync(join(tmpdir(), "coreframe-upgrade-skill-"))
-  const targetPath = join(dir, "SKILL.md")
-
-  try {
-    writeFileSync(targetPath, targetText)
-    const diff = git([
-      "--no-pager",
-      "diff",
-      "--no-index",
-      "--color=never",
-      "--",
-      localPath,
-      targetPath,
-    ])
-    const output = errorDetail(diff)
-
-    if (output) {
-      console.log(output)
-    }
-  } finally {
-    rmSync(dir, { force: true, recursive: true })
-  }
-}
-
-export function checkUpgradeSkillCurrent({ apply, target }: CheckUpgradeSkillOptions) {
-  const repoRoot = getRepoRoot()
-  const localPath = join(repoRoot, skillPath)
-
-  if (!existsSync(localPath)) {
-    throw new Error(`Local ${skillPath} does not exist.`)
-  }
-
-  const localText = readFileSync(localPath, "utf8")
-  const targetText = readGitFile(target, skillPath)
-
-  if (localText === targetText) {
-    console.log(`Coreframe upgrade skill matches ${target}:${skillPath}.`)
-    return 0
-  }
-
-  if (apply) {
-    writeFileSync(localPath, targetText)
-    console.error(`Updated ${skillPath} from ${target}. Reread it before continuing the upgrade.`)
-    return 20
-  }
-
-  console.error(`Coreframe upgrade skill differs from ${target}:${skillPath}.`)
-  console.error(`Run again with --apply to update it, then reread ${skillPath} before continuing.`)
-  printDiff(localPath, targetText)
-  return 20
-}
-
-if (import.meta.main) {
-  const targetIndex = process.argv.indexOf("--target")
-  const target = targetIndex === -1 ? null : process.argv[targetIndex + 1]
-
-  if (!target) {
-    console.error("Usage: coreframe upgrade check-skill-current --target <git-ref> [--apply]")
-    process.exit(64)
-  }
-
-  try {
-    process.exit(checkUpgradeSkillCurrent({ apply: process.argv.includes("--apply"), target }))
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error))
-    process.exit(65)
-  }
-}

package/upgrade/ensure-template-remote.ts

@@ -1,79 +0,0 @@
-#!/usr/bin/env node
-import { spawnSync } from "node:child_process"
-
-const defaultRemote = "template"
-const defaultUrl = "https://github.com/airlock-labs/coreframe.git"
-
-export type EnsureTemplateRemoteOptions = {
-  fetch: boolean
-  remote: string
-}
-
-function git(args: string[]) {
-  return spawnSync("git", args, { encoding: "utf8" })
-}
-
-function runGit(args: string[]) {
-  const result = git(args)
-
-  if (result.status !== 0) {
-    const detail = result.stderr.trim() || result.stdout.trim()
-    throw new Error(`Git command failed: git ${args.join(" ")}${detail ? `\n${detail}` : ""}`)
-  }
-
-  return result.stdout
-}
-
-function getRemoteUrl(remote: string) {
-  const result = git(["remote", "get-url", remote])
-
-  if (result.status === 2) {
-    return null
-  }
-
-  if (result.status !== 0) {
-    const detail = result.stderr.trim() || result.stdout.trim()
-    throw new Error(`Could not inspect remote ${remote}.${detail ? `\n${detail}` : ""}`)
-  }
-
-  return result.stdout.trim()
-}
-
-export function ensureTemplateRemote({
-  fetch = true,
-  remote = defaultRemote,
-}: Partial<EnsureTemplateRemoteOptions> = {}) {
-  if (remote.length === 0) {
-    throw new Error("Remote name must not be empty.")
-  }
-
-  runGit(["rev-parse", "--show-toplevel"])
-
-  const existingUrl = getRemoteUrl(remote)
-
-  if (existingUrl === null) {
-    runGit(["remote", "add", remote, defaultUrl])
-    console.log(`Added ${remote} remote: ${defaultUrl}`)
-  } else if (existingUrl === defaultUrl) {
-    console.log(`${remote} remote already points at ${defaultUrl}`)
-  } else {
-    throw new Error(
-      `${remote} remote points at ${existingUrl}, not ${defaultUrl}.\n` +
-        "Choose the intended template source before continuing, then update or rename the remote manually.",
-    )
-  }
-
-  if (fetch) {
-    runGit(["fetch", remote, "--tags", "--prune"])
-    console.log(`Fetched ${remote}.`)
-  }
-}
-
-if (import.meta.main) {
-  try {
-    ensureTemplateRemote({ fetch: !process.argv.includes("--no-fetch") })
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error))
-    process.exit(65)
-  }
-}