@duypham93/openkit 0.2.5 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duypham93/openkit",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "type": "module",
   "files": [
     ".opencode/",

package/src/global/workspace-shim.js

@@ -1,6 +1,14 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+function removePathIfPresent(targetPath) {
+  try {
+    fs.rmSync(targetPath, { recursive: true, force: true });
+  } catch {
+    // ignore cleanup failures
+  }
+}
+
 function ensureParent(filePath) {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
 }
@@ -13,6 +21,10 @@ function writeFile(filePath, content, mode) {
   }
 }
 
+function writeJson(filePath, value) {
+  writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
 function relativeTarget(fromPath, toPath) {
   return path.relative(path.dirname(fromPath), toPath) || '.';
 }
@@ -22,7 +34,7 @@ function createSymlinkOrCopy({ linkPath, targetPath, type = 'file' }) {
 
   try {
     if (fs.existsSync(linkPath) || fs.lstatSync(linkPath)) {
-      fs.rmSync(linkPath, { recursive: true, force: true });
+      removePathIfPresent(linkPath);
     }
   } catch {
     // ignore cleanup misses
@@ -42,28 +54,40 @@ function createSymlinkOrCopy({ linkPath, targetPath, type = 'file' }) {
   }
 }
 
+function createIfMissing(createdPaths, { linkPath, targetPath, type = 'file' }) {
+  if (fs.existsSync(linkPath)) {
+    return null;
+  }
+
+  const mode = createSymlinkOrCopy({ linkPath, targetPath, type });
+  createdPaths.push(linkPath);
+  return mode;
+}
+
 export function ensureWorkspaceShim(paths) {
+  const createdPaths = [];
+
   fs.mkdirSync(paths.workspaceShimDir, { recursive: true });
 
-  createSymlinkOrCopy({
+  createIfMissing(createdPaths, {
     linkPath: paths.workspaceShimAgentsPath,
     targetPath: path.join(paths.kitRoot, 'AGENTS.md'),
     type: 'file',
   });
 
-  createSymlinkOrCopy({
+  createIfMissing(createdPaths, {
     linkPath: paths.workspaceShimContextDir,
     targetPath: path.join(paths.kitRoot, 'context'),
     type: 'dir',
   });
 
-  createSymlinkOrCopy({
+  createIfMissing(createdPaths, {
     linkPath: paths.workspaceShimTemplatesDir,
     targetPath: path.join(paths.kitRoot, 'docs', 'templates'),
     type: 'dir',
   });
 
-  createSymlinkOrCopy({
+  createIfMissing(createdPaths, {
     linkPath: paths.workspaceShimWorkflowStatePath,
     targetPath: paths.workflowStatePath,
     type: 'file',
@@ -85,20 +109,97 @@ if (result.error) {
 process.exit(typeof result.status === 'number' ? result.status : 1);
 `;
 
-  writeFile(paths.workspaceShimWorkflowCliPath, workflowCli, 0o755);
+  if (!fs.existsSync(paths.workspaceShimWorkflowCliPath)) {
+    writeFile(paths.workspaceShimWorkflowCliPath, workflowCli, 0o755);
+    createdPaths.push(paths.workspaceShimWorkflowCliPath);
+  }
 
-  const gitDir = path.join(paths.projectRoot, '.git');
-  if (fs.existsSync(gitDir)) {
-    const excludePath = path.join(gitDir, 'info', 'exclude');
-    const entry = '.opencode/openkit/';
-    let current = '';
-    if (fs.existsSync(excludePath)) {
-      current = fs.readFileSync(excludePath, 'utf8');
-    }
-    if (!current.split(/\r?\n/).includes(entry)) {
-      writeFile(excludePath, `${current}${current.endsWith('\n') || current.length === 0 ? '' : '\n'}${entry}\n`);
-    }
+  createIfMissing(createdPaths, {
+    linkPath: path.join(paths.projectRoot, 'AGENTS.md'),
+    targetPath: paths.workspaceShimAgentsPath,
+    type: 'file',
+  });
+
+  createIfMissing(createdPaths, {
+    linkPath: path.join(paths.projectRoot, 'context'),
+    targetPath: paths.workspaceShimContextDir,
+    type: 'dir',
+  });
+
+  createIfMissing(createdPaths, {
+    linkPath: path.join(paths.projectRoot, '.opencode', 'workflow-state.json'),
+    targetPath: paths.workspaceShimWorkflowStatePath,
+    type: 'file',
+  });
+
+  const opencodeRoot = path.join(paths.projectRoot, '.opencode');
+  const opencodePackagePath = path.join(opencodeRoot, 'package.json');
+  if (!fs.existsSync(opencodePackagePath)) {
+    writeJson(opencodePackagePath, { type: 'module' });
+    createdPaths.push(opencodePackagePath);
   }
 
-  return paths;
+  if (!fs.existsSync(path.join(paths.projectRoot, '.opencode', 'workflow-state.js'))) {
+    const rootWorkflowCli = `#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+
+const rawArgs = process.argv.slice(2);
+const command = rawArgs[0];
+const aliasMap = new Map([
+  ['get', 'show'],
+  ['--help', 'help'],
+  ['-h', 'help'],
+]);
+const normalizedArgs = rawArgs.length === 0 ? ['help'] : [aliasMap.get(command) ?? command, ...rawArgs.slice(1)];
+const result = spawnSync(process.execPath, [${JSON.stringify(paths.workspaceShimWorkflowCliPath)}, ...normalizedArgs], {
+  stdio: 'inherit',
+  env: process.env,
+});
+
+if (result.error) {
+  throw result.error;
+}
+
+process.exit(typeof result.status === 'number' ? result.status : 1);
+`;
+
+    const rootWorkflowCliPath = path.join(paths.projectRoot, '.opencode', 'workflow-state.js');
+    writeFile(rootWorkflowCliPath, rootWorkflowCli, 0o755);
+    createdPaths.push(rootWorkflowCliPath);
+  }
+
+  if (!fs.existsSync(path.join(paths.projectRoot, '.opencode', 'work-items'))) {
+    createIfMissing(createdPaths, {
+      linkPath: path.join(paths.projectRoot, '.opencode', 'work-items'),
+      targetPath: paths.workItemsDir,
+      type: 'dir',
+    });
+  }
+
+  return {
+    paths,
+    createdPaths,
+  };
+}
+
+export function cleanupWorkspaceShim(shim) {
+  if (!shim?.createdPaths) {
+    return;
+  }
+
+  for (const createdPath of [...shim.createdPaths].reverse()) {
+    removePathIfPresent(createdPath);
+  }
+
+  const maybeShimDir = shim.paths?.workspaceShimDir;
+  if (maybeShimDir && fs.existsSync(maybeShimDir)) {
+    try {
+      const entries = fs.readdirSync(maybeShimDir);
+      if (entries.length === 0) {
+        removePathIfPresent(maybeShimDir);
+      }
+    } catch {
+      // ignore cleanup misses
+    }
+  }
 }

package/src/global/workspace-state.js

@@ -51,9 +51,12 @@ export function ensureWorkspaceBootstrap(options = {}) {
     });
   }
 
-  ensureWorkspaceShim(paths);
+  const shim = ensureWorkspaceShim(paths);
 
-  return paths;
+  return {
+    ...paths,
+    workspaceShim: shim,
+  };
 }
 
 export function readWorkspaceMeta(options = {}) {

package/tests/cli/openkit-cli.test.js

@@ -33,6 +33,10 @@ function writeExecutable(filePath, content) {
   fs.chmodSync(filePath, 0o755);
 }
 
+function removePathIfPresent(targetPath) {
+  fs.rmSync(targetPath, { recursive: true, force: true });
+}
+
 test('openkit --help shows global-install oriented help', () => {
   const result = runCli(['--help']);
 
@@ -226,6 +230,10 @@ process.stdout.write('mock opencode launched\\n');
   assert.equal(fs.existsSync(path.join(projectRoot, '.opencode', 'openkit', 'context', 'core', 'workflow.md')), true);
   assert.equal(fs.lstatSync(path.join(projectRoot, '.opencode', 'openkit', 'workflow-state.json')).isSymbolicLink() || fs.existsSync(path.join(projectRoot, '.opencode', 'openkit', 'workflow-state.json')), true);
   assert.equal(fs.existsSync(path.join(projectRoot, '.opencode', 'openkit', 'workflow-state.js')), true);
+  assert.equal(fs.existsSync(path.join(projectRoot, 'AGENTS.md')), true);
+  assert.equal(fs.existsSync(path.join(projectRoot, 'context', 'core', 'workflow.md')), true);
+  assert.equal(fs.lstatSync(path.join(projectRoot, '.opencode', 'workflow-state.json')).isSymbolicLink() || fs.existsSync(path.join(projectRoot, '.opencode', 'workflow-state.json')), true);
+  assert.equal(fs.existsSync(path.join(projectRoot, '.opencode', 'workflow-state.js')), true);
 });
 
 test('openkit run does not reinstall when the global install already exists', () => {
@@ -301,6 +309,88 @@ process.stdout.write('mock opencode launched after auto-install\\n');
   assert.equal(fs.existsSync(path.join(projectRoot, '.opencode', 'openkit', 'AGENTS.md')), true);
 });
 
+test('openkit run does not overwrite existing repo-local workflow files when creating shims', () => {
+  const tempHome = makeTempDir();
+  const projectRoot = makeTempDir();
+  const fakeBinDir = path.join(tempHome, 'bin');
+
+  fs.mkdirSync(path.join(projectRoot, '.opencode'), { recursive: true });
+  fs.mkdirSync(path.join(projectRoot, 'context', 'core'), { recursive: true });
+  fs.writeFileSync(path.join(projectRoot, 'AGENTS.md'), 'project agents\n', 'utf8');
+  fs.writeFileSync(path.join(projectRoot, 'context', 'core', 'workflow.md'), 'project workflow\n', 'utf8');
+  fs.writeFileSync(path.join(projectRoot, '.opencode', 'workflow-state.json'), '{"project":true}\n', 'utf8');
+  fs.writeFileSync(path.join(projectRoot, '.opencode', 'workflow-state.js'), '#!/usr/bin/env node\n', 'utf8');
+
+  writeExecutable(path.join(fakeBinDir, 'opencode'), '#!/bin/sh\nexit 0\n');
+
+  const result = runCli(['run'], {
+    cwd: projectRoot,
+    env: {
+      ...process.env,
+      OPENCODE_HOME: tempHome,
+      PATH: `${fakeBinDir}${path.delimiter}${process.env.PATH}`,
+    },
+  });
+
+  assert.equal(result.status, 0);
+  assert.equal(fs.readFileSync(path.join(projectRoot, 'AGENTS.md'), 'utf8'), 'project agents\n');
+  assert.equal(fs.readFileSync(path.join(projectRoot, 'context', 'core', 'workflow.md'), 'utf8'), 'project workflow\n');
+  assert.equal(fs.readFileSync(path.join(projectRoot, '.opencode', 'workflow-state.json'), 'utf8'), '{"project":true}\n');
+  assert.equal(fs.readFileSync(path.join(projectRoot, '.opencode', 'workflow-state.js'), 'utf8'), '#!/usr/bin/env node\n');
+  assert.equal(fs.existsSync(path.join(projectRoot, '.opencode', 'openkit', 'AGENTS.md')), true);
+});
+
+test('openkit run cleans root compatibility shims when created files are removed', () => {
+  const tempHome = makeTempDir();
+  const projectRoot = makeTempDir();
+  const fakeBinDir = path.join(tempHome, 'bin');
+
+  writeExecutable(path.join(fakeBinDir, 'opencode'), '#!/bin/sh\nexit 0\n');
+
+  const result = runCli(['run'], {
+    cwd: projectRoot,
+    env: {
+      ...process.env,
+      OPENCODE_HOME: tempHome,
+      PATH: `${fakeBinDir}${path.delimiter}${process.env.PATH}`,
+    },
+  });
+
+  assert.equal(result.status, 0);
+  assert.equal(fs.existsSync(path.join(projectRoot, 'AGENTS.md')), true);
+
+  removePathIfPresent(path.join(projectRoot, 'AGENTS.md'));
+  removePathIfPresent(path.join(projectRoot, 'context'));
+  removePathIfPresent(path.join(projectRoot, '.opencode', 'workflow-state.json'));
+  removePathIfPresent(path.join(projectRoot, '.opencode', 'workflow-state.js'));
+
+  assert.equal(fs.existsSync(path.join(projectRoot, '.opencode', 'openkit', 'AGENTS.md')), true);
+});
+
+test('openkit run creates a module-aware root workflow wrapper with alias support', () => {
+  const tempHome = makeTempDir();
+  const projectRoot = makeTempDir();
+  const fakeBinDir = path.join(tempHome, 'bin');
+
+  writeExecutable(path.join(fakeBinDir, 'opencode'), '#!/bin/sh\nexit 0\n');
+
+  const result = runCli(['run'], {
+    cwd: projectRoot,
+    env: {
+      ...process.env,
+      OPENCODE_HOME: tempHome,
+      PATH: `${fakeBinDir}${path.delimiter}${process.env.PATH}`,
+    },
+  });
+
+  assert.equal(result.status, 0);
+  assert.deepEqual(readJson(path.join(projectRoot, '.opencode', 'package.json')), { type: 'module' });
+
+  const wrapper = fs.readFileSync(path.join(projectRoot, '.opencode', 'workflow-state.js'), 'utf8');
+  assert.match(wrapper, /\['get', 'show'\]/);
+  assert.match(wrapper, /\['--help', 'help'\]/);
+});
+
 test('openkit run reports missing opencode after first-time setup completes', () => {
   const tempHome = makeTempDir();
   const projectRoot = makeTempDir();