skiv 0.0.5 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skiv",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "publishConfig": {
     "access": "public"
   },
@@ -22,7 +22,7 @@
   "types": "dist/esm/index.d.ts",
   "files": [
     "bin",
-    "dist",
+    "skiv",
     "skeleton"
   ],
   "bin": {

package/skiv/IssueService.ts

@@ -0,0 +1,257 @@
+import {Database} from "./db";
+import {isIssuePriority, isIssueStatus, Issue, ISSUE_PRIORITIES, IssueStatus} from "./db/schema";
+import {executeImmediate} from "./utils";
+
+/**
+ * Provides services and operations for managing issues in the system.
+ */
+export class IssueService {
+
+  constructor(private db: Database) {
+  }
+
+  /**
+   * Creates a new issue with the given title, priority, and optional description.
+   *
+   * @param {string} title - The title of the issue to be created. This parameter is required.
+   * @param {string} [priority="mid"] - The priority level of the issue. Defaults to "mid" if not provided.
+   * @param {string | null} description - A description of the issue. Defaults to null if not provided.
+   * @return {Promise<Issue>} A promise that resolves to the created Issue object.
+   * @throws {Error} If the title is not provided.
+   * @throws {Error} If the provided priority value is invalid.
+   * @throws {Error} If the issue creation fails.
+   */
+  public async create(title: string, priority: string = "mid", description: string | null = null): Promise<Issue> {
+    if (!title) {
+      throw new Error("title required")
+    }
+
+    if (!isIssuePriority(priority)) {
+      throw new Error(`Invalid priority: ${priority} (valid values: ${ISSUE_PRIORITIES.join(", ")})`)
+    }
+
+    const row = await this.db
+      .insertInto('issues')
+      .values({
+        status: "todo",
+        title,
+        assignee: null,
+        priority,
+        description,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString()
+      })
+      .returning('id')
+      .executeTakeFirst()
+
+    if (!row) {
+      throw new Error("Failed to create issue")
+    }
+
+    const issue = await this.findById(row.id)
+    if (!issue) {
+      throw new Error("Failed to retrieve newly created issue")
+    }
+
+    return issue
+  }
+
+  /**
+   * Retrieves a list of issues filtered by their status.
+   *
+   * @param {string | undefined} status - The status to filter issues by. If undefined, retrieves all issues regardless of status.
+   * @return {Promise<Partial<Issue>[]>} A promise resolving to a list of issues matching the specified status.
+   */
+  public async listIssues(status?: IssueStatus): Promise<Partial<Issue>[]> {
+    if (status !== undefined && !isIssueStatus(status)) {
+      throw new Error(`Invalid status: ${status}`)
+    }
+    let query = this.db
+      .selectFrom('issues')
+      .selectAll()
+    if (status) {
+      query = query.where('status', '=', status)
+    }
+    return query
+      .orderBy('created_at', 'asc')
+      .execute()
+  }
+
+  /**
+   * Retrieves the first assigned issue for a given assignee where the issue status is 'in_progress'.
+   * If no assigned issue is found, it attempts to assign the next available issue.
+   *
+   * @param {string} assignee - The username or identifier of the assignee whose issue needs to be fetched.
+   * @param {IssueStatus} status - The status of the issue to be fetched. Defaults to 'in_progress'.
+   * @return {Promise<Issue | null>} A promise that resolves to the assigned issue if found, or null if no matching issue is found.
+   */
+  public async getAssignedIssue(assignee: string, status: IssueStatus): Promise<Issue | null> {
+    const row = await this.db.selectFrom('issues')
+      .select(['id'])
+      .where('status', '=', status)
+      .where('assignee', '=', assignee)
+      .orderBy('id', 'asc')
+      .executeTakeFirst()
+
+    if (!row) return null
+
+    return this.findById(row.id)
+  }
+
+  /**
+   * Retrieves the next available issue based on the current status and assigns it to the specified assignee.
+   * Updates the status and assignee of the issue upon retrieval.
+   *
+   * @param {IssueStatus} fromStatus - The current status of the issue to be retrieved.
+   * @param {IssueStatus} toStatus - The status to update the issue to after retrieval.
+   * @param {string} assignee - The identifier of the assignee for the issue.
+   * @return {Promise<Issue | null>} A promise that resolves to the next issue object or null if no such issue exists.
+   */
+  public async getNextIssue(fromStatus: IssueStatus, toStatus: IssueStatus, assignee: string): Promise<Issue | null> {
+
+    const id = await executeImmediate(this.db, async (trx) => {
+
+      let query = trx
+        .selectFrom('issues')
+        .selectAll()
+        .where('status', '=', fromStatus)
+      // .where('assignee', 'is', null)
+
+      query = query.orderBy('created_at', 'asc')
+
+      const nextIssue = await query.executeTakeFirst()
+
+      if (!nextIssue) return null
+
+      await trx.updateTable('issues')
+        .set({
+          status: toStatus,
+          assignee: assignee,
+          updated_at: new Date().toISOString()
+        })
+        .where('id', '=', nextIssue.id)
+        .execute()
+
+      return nextIssue.id
+    })
+
+    if (!id) return null
+    return this.findById(id)
+  }
+
+  /**
+   * Adds a comment to the specified issue.
+   *
+   * @param {number} issueId - The unique identifier of the issue to comment on.
+   * @param {string} by - The username or identifier of the person making the comment.
+   * @param {string} message - The content of the comment.
+   * @return {Promise<Issue>} A promise that resolves to the updated issue object with the new comment included.
+   */
+  public async comment(issueId: number, by: string, message: string): Promise<Issue> {
+    const issue = await this.findById(issueId)
+    if (!issue) {
+      throw new Error(`Issue #${issueId} not found`)
+    }
+
+    await this.db
+      .insertInto('comments')
+      .values({
+        issue_id: issue.id,
+        by,
+        message,
+        at: new Date().toISOString()
+      })
+      .execute()
+
+    const returnIssue = await this.findById(issueId)
+    if (!returnIssue) {
+      throw new Error(`Failed to retrieve issue #${issueId} after commenting`)
+    }
+
+    return returnIssue
+  }
+
+  /**
+   * Updates the status of an issue.
+   *
+   * @param {number} issueId - The ID of the issue to be updated.
+   * @param {IssueStatus} status - The new status to assign to the issue.
+   * @returns {Promise<Issue>} The updated issue.
+   * @throws {Error} If the issue is not found.
+   */
+  async updateStatus(issueId: number, status: IssueStatus): Promise<Issue> {
+    const issue = await this.findById(issueId)
+    if (!issue) {
+      throw new Error(`Issue #${issueId} not found`)
+    }
+
+    await this.db
+      .updateTable('issues')
+      .set({
+        status,
+        updated_at: new Date().toISOString()
+      })
+      .where('id', '=', issueId)
+      .execute()
+
+    const returnIssue = await this.findById(issueId)
+    if (!returnIssue) {
+      throw new Error(`Failed to retrieve issue #${issueId} after updating status`)
+    }
+
+    return returnIssue
+  }
+
+  /**
+   * Updates the assignee of a specific issue by its ID.
+   *
+   * @param {number} issueId - The unique identifier of the issue to update.
+   * @param {string | null} assignee - The new assignee for the issue. Pass null to unassign.
+   * @return {Promise<Issue>} A promise that resolves to the updated issue object.
+   * @throws {Error} If the issue with the given ID does not exist or cannot be retrieved after the update.
+   */
+  async updateAssignee(issueId: number, assignee: string | null): Promise<Issue> {
+    const issue = await this.findById(issueId)
+    if (!issue) {
+      throw new Error(`Issue #${issueId} not found`)
+    }
+
+    await this.db
+      .updateTable('issues')
+      .set({
+        assignee,
+        updated_at: new Date().toISOString()
+      })
+      .where('id', '=', issueId)
+      .execute()
+
+    const returnIssue = await this.findById(issueId)
+    if (!returnIssue) {
+      throw new Error(`Failed to retrieve issue #${issueId} after updating assignee`)
+    }
+
+    return returnIssue
+  }
+
+  /**
+   * Finds an issue by its unique identifier.
+   *
+   * @param {number} id - The unique identifier of the issue to retrieve.
+   * @return {Promise<Issue | null>} A promise that resolves to the issue with its associated comments if found, or null if no issue is found with the given identifier.
+   */
+  private async findById(id: number): Promise<Issue | null> {
+    const row = await this.db.selectFrom('issues')
+      .selectAll()
+      .where('id', '=', id)
+      .executeTakeFirst()
+    if (!row) return null
+
+    const comments = await this.db.selectFrom('comments')
+      .selectAll()
+      .where('issue_id', '=', id)
+      .orderBy('at', 'asc')
+      .execute()
+
+    return {...row, comments}
+  }
+}

package/skiv/Logger.ts

@@ -0,0 +1,47 @@
+const LogLevels = {
+  DEBUG: 0,
+  INFO: 1,
+  WARNING: 2,
+  ERROR: 3,
+  CRITICAL: 4,
+} as const;
+
+export type LogLevel = keyof typeof LogLevels;
+
+export default class Logger {
+
+  constructor(
+    private level: LogLevel
+  ) {
+  }
+
+  private log(message: string | number | boolean | object, level: LogLevel) {
+    if (LogLevels[level] >= LogLevels[this.level]) {
+      console.log(message)
+    }
+  }
+
+  public debug(message: string | number | boolean | object) {
+    this.log(message, "DEBUG")
+  }
+
+  public info(message: string | number | boolean | object) {
+    this.log(message, "INFO")
+  }
+
+  public warn(message: string | number | boolean | object) {
+    this.log(message, "WARNING")
+  }
+
+  public error(message: string | number | boolean | object) {
+    this.log(`\x1b[31m${message}\x1b[0m`, "ERROR")
+  }
+
+  public critical(message: string | number | boolean | object) {
+    this.log(`\x1b[32m${message}\x1b[0m`, "CRITICAL")
+  }
+
+  public static log(message: string | number | boolean | object) {
+    console.log(message)
+  }
+}

package/skiv/Worker.ts

@@ -0,0 +1,154 @@
+import {spawn, SpawnOptions} from "child_process"
+import fs from "fs";
+import path from "path";
+import {SimpleGit, simpleGit} from "simple-git";
+import {Database} from "./db";
+import {IssueService} from "./IssueService"
+import Logger, {type LogLevel} from "./Logger";
+import {clearScreen, sleep} from "./utils"
+
+export default class Worker {
+
+  protected LOG_LEVEL: LogLevel = "INFO"
+
+  protected issueService: IssueService
+  protected logger: Logger
+  protected rootGit: SimpleGit
+  protected git: SimpleGit
+
+  protected NAME: string
+  protected WORKSPACE: string
+  protected WORKTREE: string
+  protected LOOP_INTERVAL_MSEC: number = 5000
+  protected MODEL: string
+  protected PROMPT: string
+
+  constructor(db: Database, name: string, workspace: string, model: string) {
+
+    clearScreen()
+    this.NAME = name
+    this.WORKSPACE = workspace
+    this.WORKTREE = path.resolve(workspace, 'worktree')
+    this.MODEL = model
+    this.PROMPT = `あなたの名前は${this.NAME}です。CLAUDE.mdに沿って処理をしてください。`
+
+    this.issueService = new IssueService(db)
+    this.logger = new Logger(this.LOG_LEVEL)
+    this.rootGit = simpleGit()
+
+    if (!fs.existsSync(this.WORKTREE)) {
+      fs.mkdirSync(this.WORKTREE, {recursive: true})
+    }
+    this.git = simpleGit(this.WORKTREE)
+
+    if (!this.NAME) {
+      throw new Error('arg 0 name required')
+    }
+  }
+
+  public async loop() {
+    while (true) {
+      // clearScreen()
+      this.logger.debug("LOOP START")
+
+      const beforeValue = await this.before()
+      if (beforeValue) {
+        const response = await this.execute()
+        await this.after(response)
+      }
+
+      this.logger.debug("LOOP END")
+      await sleep(this.LOOP_INTERVAL_MSEC)
+    }
+  }
+
+  public async before(): Promise<boolean> {
+    return Promise.resolve(true)
+  }
+
+  public async execute(): Promise<string> {
+    return this.spawn(
+      "claude",
+      [
+        "--model", this.MODEL,
+        "--dangerously-skip-permissions",
+        "-p", `"${this.PROMPT}"`
+      ],
+      {
+        stdio: ["inherit", "pipe", "pipe"],
+      }
+    )
+  }
+
+  public async after(response: string): Promise<void> {
+  }
+
+  protected async setupWorktree(branch: string, base: string = 'main'): Promise<void> {
+    this.logger.debug(`setupWorktree(${branch})`)
+
+    const branchExists = (await this.rootGit.branchLocal()).all.includes(branch)
+
+    const args = ['worktree', 'add', this.WORKTREE]
+
+    if (!branchExists) {
+      args.push('-B', branch, base);
+    } else {
+      args.push(branch);
+    }
+
+    try {
+      await this.rootGit.raw(args);
+    } catch (error: unknown) {
+      this.logger.error(`failed to setup worktree: ${error}`)
+      process.exit(1)
+    }
+  }
+
+  protected async cleanupWorktree(): Promise<void> {
+    this.logger.debug(`cleanupWorktree()`)
+    try {
+      await this.rootGit.raw(['worktree', 'remove', '--force', this.WORKTREE]);
+    } catch (e) {
+      // pass
+    }
+    try {
+      await this.rootGit.raw(['worktree', 'prune']);
+      fs.rmSync(this.WORKTREE, {recursive: true, force: true})
+    } catch (error: unknown) {
+      this.logger.error(`failed to cleanup worktree: ${error}`)
+      process.exit(1)
+    }
+  }
+
+  protected async spawn(command: string, args: string[], options: SpawnOptions = {}): Promise<string> {
+
+    return new Promise((resolve, reject) => {
+
+      Logger.log(`💻 ${command} ${args.join(' ')}`)
+
+      let stdout = ''
+      const child = spawn(command, args, options)
+
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+        this.logger.info(chunk.toString())
+      })
+
+      child.stderr?.on("data", (chunk) => {
+        this.logger.error(chunk.toString())
+      })
+
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve(stdout)
+        } else {
+          reject(new Error(`Process exited with code ${code}`));
+        }
+      })
+
+      child.on("error", (err) => {
+        reject(err);
+      })
+    })
+  }
+}

package/skiv/cli.ts

@@ -0,0 +1,107 @@
+import {program, Argument, Option} from 'commander'
+import RunCommand from "./commands/RunCommand";
+import InitCommand from "./commands/InitCommand";
+import IssueCommand from "./commands/IssueCommand";
+import StartCommand from "./commands/StartCommand";
+import {ISSUE_STATUSES, IssueStatus} from './db/schema'
+
+program
+  .name('skiv')
+  .description('Claude Code orchestration tool')
+  .version('0.0.1')
+
+// init
+program.command('init')
+  .description('Initialize skiv')
+  .action(async () => {
+    const command = new InitCommand()
+    await command.execute()
+  })
+
+// start
+program.command('start')
+  .description('run skiv')
+  .action(async () => {
+    const command = new StartCommand()
+    await command.execute()
+  })
+
+// run
+program.command('run')
+  .description('run member')
+  .argument('<name>', 'member name')
+  .argument('[model]', 'model name', 'sonnet')
+  .action(async (name: string, model: string) => {
+    const command = new RunCommand()
+    await command.execute(name, model)
+  })
+
+// issue
+const issue = program.command('issue')
+  .description('Issue manager')
+
+// create
+issue.command('create')
+  .description('create a new issue')
+  .argument('<title>', 'issue title')
+  .addArgument(
+    new Argument('[priority]', 'issue priority')
+      .choices(['low', 'mid', 'high'])
+      .default('mid')
+  )
+  .argument('[description]', 'spec')
+  .action(async (title: string, priority?: string, description?: string) => {
+    const command = new IssueCommand()
+    await command.create(title, priority, description)
+  })
+
+// list
+issue.command('list')
+  .description('list issues')
+  .addOption(
+    new Option('-s, --status <string>', 'filter by status')
+      .choices(ISSUE_STATUSES)
+  )
+  .action(async (options: { status?: IssueStatus }) => {
+    const command = new IssueCommand()
+    await command.list(options.status)
+  })
+
+// assign
+issue.command('assign')
+  .description('assign an issue')
+  .argument('<fromStatus>', 'search from status')
+  .argument('<toStatus>', 'change to status')
+  .argument('<assignee>', 'assignee name')
+  .action(async (fromStatus: IssueStatus, toStatus: IssueStatus, assignee: string) => {
+    const command = new IssueCommand()
+    await command.assign(fromStatus, toStatus, assignee)
+  })
+
+// comment
+issue.command('comment')
+  .description('add a comment to an issue')
+  .argument('<id>', 'issue id')
+  .argument('<by>', 'author name')
+  .argument('<message>', 'comment message')
+  .action(async (id: number, by: string, message: string) => {
+    const command = new IssueCommand()
+    await command.comment(id, by, message)
+  })
+
+// update status
+issue.command('update_status')
+  .description('update issue status')
+  .argument('<id>', 'issue id')
+  .addArgument(
+    new Argument('<status>', 'issue status')
+      .choices(ISSUE_STATUSES)
+  )
+  .action(async (id: number, status: IssueStatus) => {
+    const command = new IssueCommand()
+    await command.updateStatus(id, status)
+  })
+
+
+// parse
+program.parse()

package/skiv/commands/Command.ts

@@ -0,0 +1,45 @@
+import fs, {existsSync} from "fs"
+import path, {dirname, join} from "path"
+import {load} from 'js-yaml'
+import {createDb, Database} from "../db"
+
+interface ConfigInterface {
+  model: string
+  members: {
+    name: string
+    role: string
+  }[]
+}
+
+export default abstract class Command {
+
+  protected DIR_NAME: string = ".skiv"
+  protected CONFIG_FILE_NAME: string = "config.yaml"
+  protected DB_FILE_NAME: string = "data.db"
+
+  protected config!: ConfigInterface
+  protected db!: Database
+
+  protected initialize(): any {
+    const rootDir = this.getRootDir()
+    const yamlPath = path.resolve(rootDir, this.CONFIG_FILE_NAME)
+    const yaml = fs.readFileSync(yamlPath, 'utf-8')
+    this.config = load(yaml) as ConfigInterface
+
+    const dbPath = join(rootDir, this.DB_FILE_NAME)
+    this.db = createDb(dbPath)
+  }
+
+  protected getRootDir(): string {
+
+    let dir = process.cwd()
+
+    while (true) {
+      if (existsSync(join(dir, this.DIR_NAME))) return `${dir}/${this.DIR_NAME}`
+
+      const parent = dirname(dir)
+      if (parent === dir) throw new Error("root not found")
+      dir = parent
+    }
+  }
+}

package/skiv/commands/InitCommand.ts

@@ -0,0 +1,23 @@
+import path from "path"
+import fs from "fs-extra"
+import Command from "./Command"
+
+export default class InitCommand extends Command {
+  public async execute() {
+    const cwd = process.cwd()
+    const dest = path.join(cwd, this.DIR_NAME)
+    const skeleton = path.resolve(__dirname, "../../../skeleton")
+
+    if (fs.existsSync(dest)) {
+      console.error(`Error: Directory ${dest} already exists.`)
+      return
+    }
+
+    try {
+      await fs.copy(skeleton, dest)
+      console.log(`Initialized skiv in ${dest}`)
+    } catch (err) {
+      console.error("Failed to initialize:", err)
+    }
+  }
+}

package/skiv/commands/IssueCommand.ts

@@ -0,0 +1,40 @@
+import {IssueStatus} from "../db/schema"
+import {IssueService} from "../IssueService"
+import Command from "./Command"
+
+export default class IssueCommand extends Command {
+
+  async create(title: string, priority?: string, description?: string) {
+    this.initialize()
+    const service = new IssueService(this.db)
+    const issue = await service.create(title, priority, description)
+    console.log(`issue created: ${issue.id}`)
+  }
+
+  async list(status?: IssueStatus) {
+    this.initialize()
+    const service = new IssueService(this.db)
+    const issues = await service.listIssues(status)
+    console.table(issues)
+  }
+
+  async assign(fromStatus: IssueStatus, toStatus: IssueStatus, assignee: string) {
+    this.initialize()
+    const service = new IssueService(this.db)
+    return service.getNextIssue(fromStatus, toStatus, assignee)
+  }
+
+  async comment(id: number, by: string, message: string) {
+    this.initialize()
+    const service = new IssueService(this.db)
+    const issue = await service.comment(id, by, message)
+    console.log(`commented: ${issue.id}`)
+  }
+
+  async updateStatus(id: number, status: IssueStatus) {
+    this.initialize()
+    const service = new IssueService(this.db)
+    const issue = await service.updateStatus(id, status)
+    console.log(`updated status: ${issue.id} ${issue.status}`)
+  }
+}

package/skiv/commands/RunCommand.ts

@@ -0,0 +1,23 @@
+import fs from "fs"
+import path from "path"
+import Worker from "../Worker"
+import Command from "./Command"
+
+export default class RunCommand extends Command {
+  public async execute(name: string, model: string) {
+    this.initialize()
+
+    const dir = this.getRootDir()
+    const workspaceDir = path.resolve(dir, 'workspaces', name)
+
+    const customMemberPath = path.join(workspaceDir, 'custom.ts')
+
+    const actor = fs.existsSync(customMemberPath)
+      ? new ((await import(customMemberPath)).default as typeof Worker)(this.db, name, workspaceDir, model)
+      : new Worker(this.db, name, workspaceDir, model)
+
+    actor.loop()
+      .catch(e => console.error(e))
+      .then(() => process.exit(0))
+  }
+}

package/skiv/commands/StartCommand.ts

@@ -0,0 +1,73 @@
+import fs from "fs"
+import {execSync} from "child_process"
+import path from "path"
+import {migrateToLatest} from "../db"
+import {sendKeys} from "../utils"
+import Command from "./Command"
+
+export default class StartCommand extends Command {
+
+  /**
+   * Executes the primary workflow, including initializing resources, migrating the database to the latest schema,
+   * setting up the tmux grid, and configuring individual workspaces for team members.
+   *
+   * @return {Promise<void>} A promise that resolves when the execution of the workflow is completed.
+   */
+  public async execute(): Promise<void> {
+    this.initialize()
+    await migrateToLatest(this.db)
+
+    const dir = this.getRootDir()
+
+    const memberCount = this.config.members?.length || 0
+    const model = this.config.model || 'sonnet'
+
+    this.setupTmuxGrid(1 + memberCount)
+
+    const seWorkspace = this.createWorkspace(dir, `SE`, `se`)
+    sendKeys(0, ["(", "cd", seWorkspace, "&&", "claude", "--model", model, ")"])
+
+    for (const member of this.config.members) {
+      const index = this.config.members.indexOf(member)
+      const pane = index + 1
+      const workspace = this.createWorkspace(dir, member.name, member.role)
+      sendKeys(pane, ["(", "cd", workspace, "&&", "npx", "skiv", "run", member.name, model, ")"])
+    }
+  }
+
+  /**
+   * Creates a new workspace by copying role-specific files to the workspace directory.
+   *
+   * @param {string} rootDir - The root directory of the project.
+   * @param {string} name - The name of the workspace to be created.
+   * @param {string} role - The role associated with the workspace, used to determine the base template.
+   * @return {string} The path to the created workspace directory.
+   */
+  private createWorkspace(rootDir: string, name: string, role: string): string {
+    const workspaceDir = path.join(rootDir, 'workspaces', name)
+    const roleDir = path.join(rootDir, 'roles', role)
+
+    if (fs.existsSync(workspaceDir)) return workspaceDir
+
+    execSync(`cp -Rp ${roleDir} ${workspaceDir}`)
+
+    return workspaceDir
+  }
+
+  /**
+   * Sets up a tmux grid layout by splitting the tmux window vertically multiple times,
+   * arranging the panes in a main-horizontal layout, and adjusting the main pane's height.
+   *
+   * @param {number} paneCount - The total number of panes to create in the tmux grid.
+   * @return {void} No return value.
+   */
+  private setupTmuxGrid(paneCount: number): void {
+    for (let i = 1; i < paneCount; i++) {
+      execSync('tmux split-window -f -v')
+    }
+
+    execSync('tmux select-layout main-horizontal')
+    execSync('tmux set-window-option main-pane-height 40%')
+    execSync('tmux select-pane -t 0')
+  }
+}

package/skiv/db/index.ts

@@ -0,0 +1,25 @@
+import {Kysely, Migrator, SqliteDialect} from 'kysely'
+import SQLite from 'better-sqlite3'
+import {DatabaseSchema} from './schema'
+import {migrationProvider} from './migrations'
+
+export const createDb = (path: string): Database => {
+
+  const db = new SQLite(path);
+  db.pragma('journal_mode = WAL');
+  db.pragma('busy_timeout = 5000');
+
+  return new Kysely<DatabaseSchema>({
+    dialect: new SqliteDialect({
+      database: db,
+    }),
+  })
+}
+
+export const migrateToLatest = async (db: Database) => {
+  const migrator = new Migrator({db, provider: migrationProvider})
+  const {error} = await migrator.migrateToLatest()
+  if (error) throw error
+}
+
+export type Database = Kysely<DatabaseSchema>

package/skiv/db/migrations.ts

@@ -0,0 +1,37 @@
+import {Kysely, Migration, MigrationProvider} from 'kysely'
+
+const migrations: Record<string, Migration> = {}
+
+export const migrationProvider: MigrationProvider = {
+  async getMigrations() {
+    return migrations
+  },
+}
+
+migrations['001'] = {
+  async up(db: Kysely<unknown>) {
+    await db.schema
+      .createTable('issues')
+      .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
+      .addColumn('status', 'varchar(255)', (col) => col.notNull())
+      .addColumn('title', 'varchar(255)', (col) => col.notNull())
+      .addColumn('assignee', 'varchar(255)')
+      .addColumn('priority', 'varchar(255)')
+      .addColumn('description', 'text')
+      .addColumn('created_at', 'timestamptz', (col) => col.notNull())
+      .addColumn('updated_at', 'timestamptz', (col) => col.notNull())
+      .execute()
+    await db.schema
+      .createTable('comments')
+      .addColumn('id', 'integer', (col) => col.primaryKey().autoIncrement())
+      .addColumn('issue_id', 'integer', (col) => col.notNull().references('issues.id').onDelete('cascade'))
+      .addColumn('by', 'varchar(255)', (col) => col.notNull())
+      .addColumn('message', 'text', (col) => col.notNull())
+      .addColumn('at', 'timestamptz', (col) => col.notNull())
+      .execute()
+  },
+  async down(db: Kysely<unknown>) {
+    await db.schema.dropTable('issues').execute()
+    await db.schema.dropTable('comments').execute()
+  },
+}

package/skiv/db/schema.ts

@@ -0,0 +1,68 @@
+import {Generated} from "kysely";
+
+export type DatabaseSchema = {
+  issues: IssueTable,
+  comments: CommentTable
+}
+
+export const ISSUE_STATUSES = [
+  "todo",
+  "in_progress",
+  "pending_review",
+  "reviewing",
+  "approved",
+  "merging",
+  "done",
+  "failed",
+] as const
+export type IssueStatus = typeof ISSUE_STATUSES[number]
+export function isIssueStatus(value: unknown): value is IssueStatus {
+  return typeof value === "string" && ISSUE_STATUSES.includes(value as IssueStatus)
+}
+
+export const ISSUE_PRIORITIES = [
+  "low",
+  "mid",
+  "high",
+] as const
+export type IssuePriority = typeof ISSUE_PRIORITIES[number]
+export function isIssuePriority(value: unknown): value is IssuePriority {
+  return typeof value === "string" && ISSUE_PRIORITIES.includes(value as IssuePriority)
+}
+
+export type IssueTable = {
+  id: Generated<number>
+  status: IssueStatus
+  title: string
+  assignee: string | null
+  priority: IssuePriority | null
+  description: string | null
+  created_at: string
+  updated_at: string
+}
+
+export type CommentTable = {
+  id: Generated<number>
+  issue_id: number
+  by: string
+  message: string
+  at: string
+}
+
+export type Issue = {
+  id: number
+  status: IssueStatus
+  title: string
+  assignee: string | null
+  priority: IssuePriority | null
+  description: string | null
+  comments?: {
+    id: number
+    issue_id: number
+    by: string
+    message: string
+    at: string
+  }[]
+  created_at: string
+  updated_at: string
+}

package/skiv/utils.ts

@@ -0,0 +1,34 @@
+import {Kysely, sql} from "kysely";
+import {execSync} from "child_process";
+import {DatabaseSchema} from "./db/schema";
+
+export const clearScreen = () => process.stdout.write('\x1Bc');
+
+export function sendKeys(pane: number, command: string[]) {
+  const cmd = command.map(c => c.replaceAll(/"/g, '\\"')).join(' ')
+  execSync(`tmux send-keys -t ${pane} " ${cmd}" Enter`)
+}
+
+export function sleep(ms: number) {
+  return new Promise(r => setTimeout(r, ms))
+}
+
+export async function executeImmediate<T>(
+  db: Kysely<DatabaseSchema>,
+  callback: (trx: Kysely<DatabaseSchema>) => Promise<T>
+): Promise<T> {
+  // 1. Kyselyのインスタンスから直接 SQL を発行して BEGIN IMMEDIATE を開始
+  await sql`BEGIN IMMEDIATE`.execute(db);
+
+  try {
+    // 2. db インスタンスをそのまま callback に渡す
+    // (Kyselyの transaction ではないので、ネストエラーは出ない)
+    const result = await callback(db);
+
+    await sql`COMMIT`.execute(db);
+    return result;
+  } catch (error) {
+    await sql`ROLLBACK`.execute(db);
+    throw error;
+  }
+}