skiv 0.0.1

package/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright 2026 masashi.machida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,27 @@
+# SKIV
+
+## Installation
+
+```shell
+npm i -g skiv
+```
+
+## Usage
+
+### Initialize
+
+cd to your project directory
+
+```shell
+npx skiv init
+```
+
+generate `.skiv` directory
+
+edit `.skiv/config.yaml` and `.skiv/roles/*`
+
+### Start
+
+```shell
+npx skiv start
+```

package/bin/________________________skiv.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env tsx
+
+import "../src/cli";

package/bin/skiv.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../dist/cjs/cli.js')

package/dist/cjs/IssueService.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueService = void 0;
+const schema_1 = require("./db/schema");
+const utils_1 = require("./utils");
+/**
+ * Provides services and operations for managing issues in the system.
+ */
+class IssueService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * 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.
+     */
+    async create(title, priority = "mid", description = null) {
+        if (!title) {
+            throw new Error("title required");
+        }
+        if (!(0, schema_1.isIssuePriority)(priority)) {
+            throw new Error(`Invalid priority: ${priority} (valid values: ${schema_1.ISSUE_PRIORITIES.join(", ")})`);
+        }
+        const row = await this.db
+            .insertInto('issues')
+            .values({
+            status: "open",
+            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.
+     */
+    async listIssues(status) {
+        if (status !== undefined && !(0, schema_1.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.
+     */
+    async getAssignedIssue(assignee, status) {
+        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);
+    }
+    async getNextIssue(fromStatus, toStatus, assignee) {
+        const id = await (0, utils_1.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);
+    }
+    // /**
+    //  * Assigns the next available issue to a specified assignee.
+    //  * The next issue is determined based on its creation time,
+    //  * considering only open issues without an assigned user.
+    //  *
+    //  * @param {string} assignee - The username or identifier of the person to whom the issue will be assigned.
+    //  * @return {Promise<Issue | null>} A promise that resolves to the assigned issue object if successful, or null if no issue is available.
+    //  */
+    // public async assignNextIssue(assignee: string): Promise<Issue | null> {
+    //   const nextIssue = await this.db
+    //     .selectFrom('issues')
+    //     .selectAll()
+    //     .where('status', '=', 'open')
+    //     .where('assignee', 'is', null)
+    //     .orderBy('created_at', 'asc')
+    //     .executeTakeFirst()
+    //
+    //   if (!nextIssue) {
+    //     return null
+    //   }
+    //
+    //   return this.assignIssue(nextIssue.id, assignee)
+    // }
+    /**
+     * 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.
+     */
+    async comment(issueId, by, message) {
+        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, status) {
+        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;
+    }
+    async updateAssignee(issueId, assignee) {
+        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.
+     */
+    async findById(id) {
+        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 };
+    }
+}
+exports.IssueService = IssueService;

package/dist/cjs/Logger.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const LogLevels = {
+    DEBUG: 0,
+    INFO: 1,
+    WARNING: 2,
+    ERROR: 3,
+    CRITICAL: 4,
+};
+class Logger {
+    level;
+    constructor(level) {
+        this.level = level;
+    }
+    log(message, level) {
+        if (LogLevels[level] >= LogLevels[this.level]) {
+            console.log(message);
+        }
+    }
+    debug(message) {
+        this.log(message, "DEBUG");
+    }
+    info(message) {
+        this.log(message, "INFO");
+    }
+    warn(message) {
+        this.log(message, "WARNING");
+    }
+    error(message) {
+        this.log(`\x1b[31m${message}\x1b[0m`, "ERROR");
+    }
+    critical(message) {
+        this.log(`\x1b[32m${message}\x1b[0m`, "CRITICAL");
+    }
+    static log(message) {
+        console.log(message);
+    }
+}
+exports.default = Logger;

package/dist/cjs/Member.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const IssueService_1 = require("./IssueService");
+const Logger_1 = __importDefault(require("./Logger"));
+const utils_1 = require("./utils");
+class Member {
+    LOG_LEVEL = "INFO";
+    issueService;
+    logger;
+    NAME;
+    WORKSPACE;
+    LOOP_INTERVAL_MSEC = 5000;
+    MODEL;
+    PROMPT;
+    constructor(db, name, workspace, model) {
+        this.issueService = new IssueService_1.IssueService(db);
+        this.logger = new Logger_1.default(this.LOG_LEVEL);
+        this.NAME = name;
+        this.WORKSPACE = workspace;
+        this.MODEL = model;
+        this.PROMPT = `あなたの名前は${this.NAME}です。CLAUDE.mdに沿って処理をしてください。`;
+        if (!this.NAME) {
+            throw new Error('arg 0 name required');
+        }
+    }
+    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 (0, utils_1.sleep)(this.LOOP_INTERVAL_MSEC);
+        }
+    }
+    async before() {
+        return Promise.resolve(true);
+    }
+    async execute() {
+        return this.spawn("claude", [
+            "--model", this.MODEL,
+            "--permission-mode", "acceptEdits",
+            "-p", `"${this.PROMPT}"`
+        ], {
+            stdio: ["inherit", "pipe", "pipe"],
+        });
+    }
+    async after(response) {
+    }
+    async spawn(command, args, options = {}) {
+        return new Promise((resolve, reject) => {
+            Logger_1.default.log(`💻 ${command} ${args.join(' ')}`);
+            let stdout = '';
+            const child = (0, child_process_1.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);
+            });
+        });
+    }
+}
+exports.default = Member;

package/dist/cjs/cli.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const RunCommand_1 = __importDefault(require("./commands/RunCommand"));
+const InitCommand_1 = __importDefault(require("./commands/InitCommand"));
+const IssueCommand_1 = __importDefault(require("./commands/IssueCommand"));
+const StartCommand_1 = __importDefault(require("./commands/StartCommand"));
+const schema_1 = require("./db/schema");
+commander_1.program
+    .name('skiv')
+    .description('Claude Code orchestration tool')
+    .version('0.0.1');
+// init
+commander_1.program.command('init')
+    .description('Initialize skiv')
+    .action(async () => {
+    const command = new InitCommand_1.default();
+    await command.execute();
+});
+// start
+commander_1.program.command('start')
+    .description('run skiv')
+    .action(async () => {
+    const command = new StartCommand_1.default();
+    await command.execute();
+});
+// run
+commander_1.program.command('run')
+    .description('dispatch member')
+    .argument('<name>', 'member name')
+    .argument('[model]', 'model name', 'sonnet')
+    .action(async (name, model) => {
+    const command = new RunCommand_1.default();
+    await command.execute(name, model);
+});
+// issue
+const issue = commander_1.program.command('issue')
+    .description('Issue manager');
+// create
+issue.command('create')
+    .description('create a new issue')
+    .argument('<title>', 'issue title')
+    .addArgument(new commander_1.Argument('[priority]', 'issue priority')
+    .choices(['low', 'mid', 'high'])
+    .default('mid'))
+    .argument('[description]', 'spec')
+    .action(async (title, priority, description) => {
+    const command = new IssueCommand_1.default();
+    await command.create(title, priority, description);
+});
+// list
+issue.command('list')
+    .description('list issues')
+    .addOption(new commander_1.Option('-s, --status <string>', 'filter by status')
+    .choices(schema_1.ISSUE_STATUSES))
+    .action(async (options) => {
+    const command = new IssueCommand_1.default();
+    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, toStatus, assignee) => {
+    const command = new IssueCommand_1.default();
+    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, by, message) => {
+    const command = new IssueCommand_1.default();
+    await command.comment(id, by, message);
+});
+// update status
+issue.command('update_status')
+    .description('update issue status')
+    .argument('<id>', 'issue id')
+    .addArgument(new commander_1.Argument('<status>', 'issue status')
+    .choices(schema_1.ISSUE_STATUSES))
+    .action(async (id, status) => {
+    const command = new IssueCommand_1.default();
+    await command.updateStatus(id, status);
+});
+// parse
+commander_1.program.parse();

package/dist/cjs/commands/Command.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importStar(require("fs"));
+const path_1 = __importStar(require("path"));
+const js_yaml_1 = require("js-yaml");
+const db_1 = require("../db");
+class Command {
+    DIR_NAME = ".skiv";
+    CONFIG_FILE_NAME = "config.yaml";
+    DB_FILE_NAME = "data.db";
+    config;
+    db;
+    initialize() {
+        const rootDir = this.getRootDir();
+        const yamlPath = path_1.default.resolve(rootDir, this.CONFIG_FILE_NAME);
+        const yaml = fs_1.default.readFileSync(yamlPath, 'utf-8');
+        this.config = (0, js_yaml_1.load)(yaml);
+        const dbPath = (0, path_1.join)(rootDir, this.DB_FILE_NAME);
+        this.db = (0, db_1.createDb)(dbPath);
+    }
+    getRootDir() {
+        let dir = process.cwd();
+        while (true) {
+            if ((0, fs_1.existsSync)((0, path_1.join)(dir, this.DIR_NAME)))
+                return `${dir}/${this.DIR_NAME}`;
+            const parent = (0, path_1.dirname)(dir);
+            if (parent === dir)
+                throw new Error("root not found");
+            dir = parent;
+        }
+    }
+}
+exports.default = Command;

package/dist/cjs/commands/InitCommand.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const Command_1 = __importDefault(require("./Command"));
+class InitCommand extends Command_1.default {
+    async execute() {
+        const cwd = process.cwd();
+        const dest = path_1.default.join(cwd, this.DIR_NAME);
+        const src = path_1.default.resolve(__dirname, "../../skeleton");
+        if (fs_extra_1.default.existsSync(dest)) {
+            console.error(`Error: Directory ${dest} already exists.`);
+            return;
+        }
+        try {
+            await fs_extra_1.default.copy(src, dest);
+            console.log(`Initialized skiv in ${dest}`);
+        }
+        catch (err) {
+            console.error("Failed to initialize:", err);
+        }
+    }
+}
+exports.default = InitCommand;

package/dist/cjs/commands/IssueCommand.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const IssueService_1 = require("../IssueService");
+const Command_1 = __importDefault(require("./Command"));
+class IssueCommand extends Command_1.default {
+    async create(title, priority, description) {
+        this.initialize();
+        const service = new IssueService_1.IssueService(this.db);
+        const issue = await service.create(title, priority, description);
+        console.log(`issue created: ${issue.id}`);
+    }
+    async list(status) {
+        this.initialize();
+        const service = new IssueService_1.IssueService(this.db);
+        const issues = await service.listIssues(status);
+        console.table(issues);
+    }
+    async assign(fromStatus, toStatus, assignee) {
+        this.initialize();
+        const service = new IssueService_1.IssueService(this.db);
+        return service.getNextIssue(fromStatus, toStatus, assignee);
+    }
+    async comment(id, by, message) {
+        this.initialize();
+        const service = new IssueService_1.IssueService(this.db);
+        const issue = await service.comment(id, by, message);
+        console.log(`commented: ${issue.id}`);
+    }
+    async updateStatus(id, status) {
+        this.initialize();
+        const service = new IssueService_1.IssueService(this.db);
+        const issue = await service.updateStatus(id, status);
+        console.log(`updated status: ${issue.id} ${issue.status}`);
+    }
+}
+exports.default = IssueCommand;